154 files changed, 13256 insertions, 369 deletions

diff --git a/src/regress/lib/libc/Makefile b/src/regress/lib/libc/Makefile
index 7b65e2c1c5..24749b95b4 100644
--- a/src/regress/lib/libc/Makefile
+++ b/src/regress/lib/libc/Makefile
@@ -1,6 +1,11 @@
-#       $NetBSD: Makefile,v 1.6 1995/04/24 05:52:15 cgd Exp $
+#       $OpenBSD: Makefile,v 1.33 2011/07/02 18:12:48 martynas Exp $
+
+SUBDIR+= _setjmp alloca atexit basename cxa-atexit db dirname fnmatch
+SUBDIR+= fpclassify getaddrinfo getcap getopt_long glob hsearch longjmp
+SUBDIR+= locale malloc netdb popen printf regex setjmp setjmp-signal
+SUBDIR+= sigreturn sigsetjmp sprintf strerror strtod strtonum telldir time vis
+SUBDIR+= orientation stdio_threading mkstemp env cephes
 
-SUBDIR+= _setjmp db regex setjmp sigsetjmp
 .if (${MACHINE_ARCH} != "vax")
 SUBDIR+= ieeefp
 .endif
@@ -9,8 +14,6 @@ SUBDIR+= ieeefp
 SUBDIR+= arch/${MACHINE_ARCH}
 .endif
 
-regress: _SUBDIRUSE
-
 install:
 
 .include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/_setjmp/Makefile b/src/regress/lib/libc/_setjmp/Makefile
index c2b9dc1aae..5d58242523 100644
--- a/src/regress/lib/libc/_setjmp/Makefile
+++ b/src/regress/lib/libc/_setjmp/Makefile
@@ -1,16 +1,11 @@
+#       $OpenBSD: Makefile,v 1.3 2002/01/01 23:00:51 art Exp $
 #       $NetBSD: Makefile,v 1.2 1995/04/20 22:38:44 cgd Exp $
 
 PROG=   _setjmptest
 SRCS=   jmptest.c
-NOMAN=  noman, no way, man
 
 CFLAGS+= -DTEST_U_SETJMP
 
 .PATH:  ${.CURDIR}/../setjmp
 
-install:
-
-regress: ${PROG}
-        ./${PROG}
-
-.include <bsd.prog.mk>
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/alloca/Makefile b/src/regress/lib/libc/alloca/Makefile
new file mode 100644
index 0000000000..f31417cda7
--- /dev/null
+++ b/src/regress/lib/libc/alloca/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/02/12 06:49:04 mickey Exp $
+
+PROG=   alloca
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/alloca/alloca.c b/src/regress/lib/libc/alloca/alloca.c
new file mode 100644
index 0000000000..54fa90edae
--- /dev/null
+++ b/src/regress/lib/libc/alloca/alloca.c
@@ -0,0 +1,21 @@
+/*      $OpenBSD: alloca.c,v 1.7 2004/03/10 01:17:45 deraadt Exp $      */
+
+/*      Written by Michael Shalayeff, 2003, Public Domain.      */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int
+main(int argc, char *argv[])
+{
+        char *q, *p;
+
+        p = alloca(41);
+        strlcpy(p, "hellow world", 41);
+
+        q = alloca(53);
+        strlcpy(q, "hellow world", 53);
+
+        exit(strcmp(p, q));
+}
diff --git a/src/regress/lib/libc/arch/alpha/Makefile b/src/regress/lib/libc/arch/alpha/Makefile
index b79a82b0e2..8c4dfb735c 100644
--- a/src/regress/lib/libc/arch/alpha/Makefile
+++ b/src/regress/lib/libc/arch/alpha/Makefile
@@ -1,10 +1,9 @@
+#       $OpenBSD: Makefile,v 1.3 2002/02/23 01:25:11 art Exp $
 #       $NetBSD: Makefile,v 1.1 1995/04/24 05:53:31 cgd Exp $
 
 # do nothing here; none of the tests here can be run automatically
 SUBDIR=
 
-regress: _SUBDIRUSE
-
 install:
 
 .include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/Makefile b/src/regress/lib/libc/arch/alpha/divremtest/Makefile
index bd3b12f537..1da3ac8494 100644
--- a/src/regress/lib/libc/arch/alpha/divremtest/Makefile
+++ b/src/regress/lib/libc/arch/alpha/divremtest/Makefile
@@ -1,3 +1,4 @@
+#       $OpenBSD: Makefile,v 1.2 2001/01/29 02:05:39 niklas Exp $
 #       $NetBSD: Makefile,v 1.1 1995/04/24 05:53:34 cgd Exp $
 
 PROG=   divremtest
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c b/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
index fcf64c9384..3d9e8a6de2 100644
--- a/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
+++ b/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: divremtest.c,v 1.2 2001/01/29 02:05:39 niklas Exp $   */
 /*      $NetBSD: divremtest.c,v 1.1 1995/04/24 05:53:35 cgd Exp $       */
 
 /*
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c b/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
index 65ca17af4c..fcb4765b8c 100644
--- a/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
+++ b/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: mkcases.c,v 1.2 2001/01/29 02:05:39 niklas Exp $      */
 /*      $NetBSD: mkcases.c,v 1.1 1995/04/24 05:53:36 cgd Exp $  */
 
 /*
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c b/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
index ef02d61d70..3b01653f32 100644
--- a/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
+++ b/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: mktestcases.c,v 1.2 2001/01/29 02:05:40 niklas Exp $  */
 /*      $NetBSD: mktestcases.c,v 1.1 1995/04/24 05:53:37 cgd Exp $      */
 
 /*
diff --git a/src/regress/lib/libc/atexit/Makefile b/src/regress/lib/libc/atexit/Makefile
new file mode 100644
index 0000000000..c14b3c7ac4
--- /dev/null
+++ b/src/regress/lib/libc/atexit/Makefile
@@ -0,0 +1,16 @@
+#       $OpenBSD: Makefile,v 1.5 2003/07/31 22:46:59 david Exp $
+
+NOMAN=
+PROG=atexit_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+CLEANFILES+= invalid.out valid.out
+
+run-regress-atexit_test: ${PROG}
+        ./${PROG} -valid 2>${.OBJDIR}/valid.out
+        cmp -s ${.OBJDIR}/valid.out ${.CURDIR}/valid.ok
+        ./${PROG} -invalid-atexit 2>${.OBJDIR}/invalid.out
+        cmp -s ${.OBJDIR}/invalid.out ${.CURDIR}/invalid.ok
+        ./${PROG} -invalid-cleanup 2>${.OBJDIR}/invalid.out
+        cmp -s ${.OBJDIR}/invalid.out ${.CURDIR}/invalid.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/atexit/atexit_test.c b/src/regress/lib/libc/atexit/atexit_test.c
new file mode 100644
index 0000000000..3dd0b62c3e
--- /dev/null
+++ b/src/regress/lib/libc/atexit/atexit_test.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: atexit_test.c,v 1.6 2007/09/03 14:42:44 millert Exp $ */
+
+/*
+ * Copyright (c) 2002 Daniel Hartmeier
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    - Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    - 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 COPYRIGHT HOLDERS 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
+ * COPYRIGHT HOLDERS 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.
+ *
+ * Effort sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F30602-01-2-0537.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include "stdlib/atexit.h"
+
+void    handle_first(void);
+void    handle_middle(void);
+void    handle_last(void);
+void    handle_invalid(void);
+void    handle_cleanup(void);
+void    handle_signal(int);
+
+static int counter;
+
+int
+main(int argc, char *argv[])
+{
+        int i;
+
+        if (argc != 2 || (strcmp(argv[1], "-valid") &&
+            strcmp(argv[1], "-invalid-atexit") &&
+            strcmp(argv[1], "-invalid-cleanup"))) {
+                fprintf(stderr, "%s -valid/-invalid-atexit/-invalid-cleanup\n",
+                    argv[0]);
+                return (1);
+        }
+        fprintf(stderr, "main()\n");
+        if (atexit(handle_last)) {
+                perror("atexit(handle_last) failed");
+                return (1);
+        }
+        for (i = 0; i < 65535; ++i) {
+                if (atexit(handle_middle)) {
+                        perror("atexit(handle_middle) failed");
+                        return (1);
+                }
+        }
+        if (atexit(handle_first)) {
+                perror("atexit(handle_first) failed");
+                return (1);
+        }
+        /* this is supposed to segfault */
+        if (!strcmp(argv[1], "-invalid-atexit")) {
+                signal(SIGSEGV, handle_signal);
+                __atexit->fns[0].fn_ptr.std_func = handle_invalid;
+        } else if (!strcmp(argv[1], "-invalid-cleanup")) {
+                struct atexit *p = __atexit;
+
+                signal(SIGSEGV, handle_signal);
+                while (p != NULL && p->next != NULL)
+                        p = p->next;
+                if (p == NULL)
+                        fprintf(stderr, "p == NULL, no page found\n");
+                p->fns[0].fn_ptr.std_func = handle_invalid;
+        }
+        __atexit_register_cleanup(handle_cleanup);
+        counter = 0;
+        fprintf(stderr, "main() returns\n");
+        return (0);
+}
+
+void
+handle_first(void)
+{
+        fprintf(stderr, "handle_first() counter == %i\n", counter);
+}
+
+void
+handle_middle(void)
+{
+        counter++;
+}
+
+void
+handle_last(void)
+{
+        fprintf(stderr, "handle_last() counter == %i\n", counter);
+}
+
+void
+handle_cleanup(void)
+{
+        fprintf(stderr, "handle_cleanup()\n");
+}
+
+void
+handle_invalid(void)
+{
+        fprintf(stderr, "handle_invalid() THIS SHOULD HAVE SEGFAULTED INSTEAD!\n");
+}
+
+void
+handle_signal(int sigraised)
+{
+        switch (sigraised) {
+        case SIGSEGV:
+                fprintf(stderr, "SIGSEGV\n");
+                exit(0);
+        default:
+                fprintf(stderr, "unexpected signal caught\n");
+                exit(1);
+        }
+}
diff --git a/src/regress/lib/libc/atexit/invalid.ok b/src/regress/lib/libc/atexit/invalid.ok
new file mode 100644
index 0000000000..98cbf8c1de
--- /dev/null
+++ b/src/regress/lib/libc/atexit/invalid.ok
@@ -0,0 +1,4 @@
+main()
+SIGSEGV
+handle_first() counter == 0
+handle_last() counter == 65535
diff --git a/src/regress/lib/libc/atexit/valid.ok b/src/regress/lib/libc/atexit/valid.ok
new file mode 100644
index 0000000000..6509e827a7
--- /dev/null
+++ b/src/regress/lib/libc/atexit/valid.ok
@@ -0,0 +1,5 @@
+main()
+main() returns
+handle_first() counter == 0
+handle_last() counter == 65535
+handle_cleanup()
diff --git a/src/regress/lib/libc/basename/Makefile b/src/regress/lib/libc/basename/Makefile
new file mode 100644
index 0000000000..958b06fd11
--- /dev/null
+++ b/src/regress/lib/libc/basename/Makefile
@@ -0,0 +1,3 @@
+PROG=basename_test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/basename/basename_test.c b/src/regress/lib/libc/basename/basename_test.c
new file mode 100644
index 0000000000..34e138c726
--- /dev/null
+++ b/src/regress/lib/libc/basename/basename_test.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2007 Bret S. Lambert <blambert@gsipt.net>
+ *
+ * Public domain.
+ */
+
+#include <sys/param.h>
+
+#include <libgen.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+int
+main(void)
+{
+        char path[2 * MAXPATHLEN];
+        const char *dir = "junk/";
+        const char *fname = "file.name.ext";
+        char *str;
+        int i;
+
+        /* Test normal functioning */
+        strlcpy(path, "/", sizeof(path));
+        strlcat(path, dir, sizeof(path)); 
+        strlcat(path, fname, sizeof(path));
+        str = basename(path);
+        if (strcmp(str, fname) != 0)
+                goto fail;
+
+        /*
+         * There are four states that require special handling:
+         *
+         * 1) path is NULL
+         * 2) path is the empty string
+         * 3) path is composed entirely of slashes
+         * 4) the resulting name is larger than MAXPATHLEN
+         *
+         * The first two cases require that a pointer
+         * to the string "." be returned.
+         *
+         * The third case requires that a pointer
+         * to the string "/" be returned.
+         *
+         * The final case requires that NULL be returned
+         * and errno * be set to ENAMETOOLONG.
+         */
+        /* Case 1 */
+        str = basename(NULL);
+        if (strcmp(str, ".") != 0)
+                goto fail;
+
+        /* Case 2 */
+        strlcpy(path, "", sizeof(path));
+        str = basename(path);
+        if (strcmp(str, ".") != 0)
+                goto fail;
+
+        /* Case 3 */
+        for (i = 0; i < MAXPATHLEN - 1; i++)
+                strlcat(path, "/", sizeof(path));       /* path cleared above */
+        str = basename(path);
+        if (strcmp(str, "/") != 0)
+                goto fail;
+
+        /* Case 4 */
+        strlcpy(path, "/", sizeof(path));
+        strlcat(path, dir, sizeof(path));
+        for (i = 0; i <= MAXPATHLEN; i += sizeof(fname))
+                strlcat(path, fname, sizeof(path));
+        str = basename(path);
+        if (str != NULL || errno != ENAMETOOLONG)
+                goto fail;
+
+        return (0);
+fail:
+        return (1);
+}
diff --git a/src/regress/lib/libc/cephes/Makefile b/src/regress/lib/libc/cephes/Makefile
new file mode 100644
index 0000000000..75cc85f4a8
--- /dev/null
+++ b/src/regress/lib/libc/cephes/Makefile
@@ -0,0 +1,7 @@
+#       $OpenBSD: Makefile,v 1.1 2011/07/02 18:11:01 martynas Exp $
+
+PROG = ieetst
+SRCS = drand.c econst.c eexp.c elog.c epow.c etanh.c etodec.c ieee.c \
+       ieetst.c mtherr.c
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/cephes/drand.c b/src/regress/lib/libc/cephes/drand.c
new file mode 100644
index 0000000000..7f7000b4e8
--- /dev/null
+++ b/src/regress/lib/libc/cephes/drand.c
@@ -0,0 +1,174 @@
+/*      $OpenBSD: drand.c,v 1.1 2011/07/02 18:11:01 martynas Exp $      */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                                      drand.c
+ *
+ *      Pseudorandom number generator
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double y, drand();
+ *
+ * drand( &y );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Yields a random number 1.0 <= y < 2.0.
+ *
+ * The three-generator congruential algorithm by Brian
+ * Wichmann and David Hill (BYTE magazine, March, 1987,
+ * pp 127-8) is used. The period, given by them, is
+ * 6953607871644.
+ *
+ * Versions invoked by the different arithmetic compile
+ * time options DEC, IBMPC, and MIEEE, produce
+ * approximately the same sequences, differing only in the
+ * least significant bits of the numbers. The UNK option
+ * implements the algorithm as recommended in the BYTE
+ * article.  It may be used on all computers. However,
+ * the low order bits of a double precision number may
+ * not be adequately random, and may vary due to arithmetic
+ * implementation details on different computers.
+ *
+ * The other compile options generate an additional random
+ * integer that overwrites the low order bits of the double
+ * precision number.  This reduces the period by a factor of
+ * two but tends to overcome the problems mentioned.
+ *
+ */
+
+#include "mconf.h"
+
+
+/*  Three-generator random number algorithm
+ * of Brian Wichmann and David Hill
+ * BYTE magazine, March, 1987 pp 127-8
+ *
+ * The period, given by them, is (p-1)(q-1)(r-1)/4 = 6.95e12.
+ */
+
+static int sx = 1;
+static int sy = 10000;
+static int sz = 3000;
+
+static union {
+ double d;
+ unsigned short s[4];
+} unkans;
+
+/* This function implements the three
+ * congruential generators.
+ */
+ 
+static int ranwh()
+{
+int r, s;
+
+/*  sx = sx * 171 mod 30269 */
+r = sx/177;
+s = sx - 177 * r;
+sx = 171 * s - 2 * r;
+if( sx < 0 )
+        sx += 30269;
+
+
+/* sy = sy * 172 mod 30307 */
+r = sy/176;
+s = sy - 176 * r;
+sy = 172 * s - 35 * r;
+if( sy < 0 )
+        sy += 30307;
+
+/* sz = 170 * sz mod 30323 */
+r = sz/178;
+s = sz - 178 * r;
+sz = 170 * s - 63 * r;
+if( sz < 0 )
+        sz += 30323;
+/* The results are in static sx, sy, sz. */
+return 0;
+}
+
+/*      drand.c
+ *
+ * Random double precision floating point number between 1 and 2.
+ *
+ * C callable:
+ *      drand( &x );
+ */
+
+int drand( a )
+double *a;
+{
+unsigned short r;
+#ifdef DEC
+unsigned short s, t;
+#endif
+
+/* This algorithm of Wichmann and Hill computes a floating point
+ * result:
+ */
+ranwh();
+unkans.d = sx/30269.0  +  sy/30307.0  +  sz/30323.0;
+r = unkans.d;
+unkans.d -= r;
+unkans.d += 1.0;
+
+/* if UNK option, do nothing further.
+ * Otherwise, make a random 16 bit integer
+ * to overwrite the least significant word
+ * of unkans.
+ */
+#ifdef UNK
+/* do nothing */
+#else
+ranwh();
+r = sx * sy + sz;
+#endif
+
+#ifdef DEC
+/* To make the numbers as similar as possible
+ * in all arithmetics, the random integer has
+ * to be inserted 3 bits higher up in a DEC number.
+ * An alternative would be put it 3 bits lower down
+ * in all the other number types.
+ */
+s = unkans.s[2];
+t = s & 07;     /* save these bits to put in at the bottom */
+s &= 0177770;
+s |= (r >> 13) & 07;
+unkans.s[2] = s;
+t |= r << 3;
+unkans.s[3] = t;
+#endif
+
+#ifdef IBMPC
+unkans.s[0] = r;
+#endif
+
+#ifdef MIEEE
+unkans.s[3] = r;
+#endif
+
+*a = unkans.d;
+return 0;
+}
diff --git a/src/regress/lib/libc/cephes/econst.c b/src/regress/lib/libc/cephes/econst.c
new file mode 100644
index 0000000000..4232059e4c
--- /dev/null
+++ b/src/regress/lib/libc/cephes/econst.c
@@ -0,0 +1,114 @@
+/*      $OpenBSD: econst.c,v 1.1 2011/07/02 18:11:01 martynas Exp $     */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                                      econst.c        */
+/*  e type constants used by high precision check routines */
+
+#include "ehead.h"
+
+
+#if NE == 10
+/* 0.0 */
+unsigned short ezero[NE] =
+ {0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,};
+
+/* 5.0E-1 */
+unsigned short ehalf[NE] =
+ {0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3ffe,};
+
+/* 1.0E0 */
+unsigned short eone[NE] =
+ {0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff,};
+
+/* 2.0E0 */
+unsigned short etwo[NE] =
+ {0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x4000,};
+
+/* 3.2E1 */
+unsigned short e32[NE] =
+ {0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x4004,};
+
+/* 6.93147180559945309417232121458176568075500134360255E-1 */
+unsigned short elog2[NE] =
+ {0x40f3, 0xf6af, 0x03f2, 0xb398,
+  0xc9e3, 0x79ab, 0150717, 0013767, 0130562, 0x3ffe,};
+
+/* 1.41421356237309504880168872420969807856967187537695E0 */
+unsigned short esqrt2[NE] =
+ {0x1d6f, 0xbe9f, 0x754a, 0x89b3,
+  0x597d, 0x6484, 0174736, 0171463, 0132404, 0x3fff,};
+
+/* 3.14159265358979323846264338327950288419716939937511E0 */
+unsigned short epi[NE] =
+ {0x2902, 0x1cd1, 0x80dc, 0x628b,
+  0xc4c6, 0xc234, 0020550, 0155242, 0144417, 0040000,};
+  
+/* 5.7721566490153286060651209008240243104215933593992E-1 */
+unsigned short eeul[NE] = {
+0xd1be,0xc7a4,0076660,0063743,0111704,0x3ffe,};
+
+#else
+
+/* 0.0 */
+unsigned short ezero[NE] = {
+0, 0000000,0000000,0000000,0000000,0000000,};
+/* 5.0E-1 */
+unsigned short ehalf[NE] = {
+0, 0000000,0000000,0000000,0100000,0x3ffe,};
+/* 1.0E0 */
+unsigned short eone[NE] = {
+0, 0000000,0000000,0000000,0100000,0x3fff,};
+/* 2.0E0 */
+unsigned short etwo[NE] = {
+0, 0000000,0000000,0000000,0100000,0040000,};
+/* 3.2E1 */
+unsigned short e32[NE] = {
+0, 0000000,0000000,0000000,0100000,0040004,};
+/* 6.93147180559945309417232121458176568075500134360255E-1 */
+unsigned short elog2[NE] = {
+0xc9e4,0x79ab,0150717,0013767,0130562,0x3ffe,};
+/* 1.41421356237309504880168872420969807856967187537695E0 */
+unsigned short esqrt2[NE] = {
+0x597e,0x6484,0174736,0171463,0132404,0x3fff,};
+/* 2/sqrt(PI) =
+ * 1.12837916709551257389615890312154517168810125865800E0 */
+unsigned short eoneopi[NE] = {
+0x71d5,0x688d,0012333,0135202,0110156,0x3fff,};
+/* 3.14159265358979323846264338327950288419716939937511E0 */
+unsigned short epi[NE] = {
+0xc4c6,0xc234,0020550,0155242,0144417,0040000,};
+/* 5.7721566490153286060651209008240243104215933593992E-1 */
+unsigned short eeul[NE] = {
+0xd1be,0xc7a4,0076660,0063743,0111704,0x3ffe,};
+#endif
+extern unsigned short ezero[];
+extern unsigned short ehalf[];
+extern unsigned short eone[];
+extern unsigned short etwo[];
+extern unsigned short e32[];
+extern unsigned short elog2[];
+extern unsigned short esqrt2[];
+extern unsigned short eoneopi[];
+extern unsigned short epi[];
+extern unsigned short eeul[];
+
diff --git a/src/regress/lib/libc/cephes/eexp.c b/src/regress/lib/libc/cephes/eexp.c
new file mode 100644
index 0000000000..74f0d6adb3
--- /dev/null
+++ b/src/regress/lib/libc/cephes/eexp.c
@@ -0,0 +1,86 @@
+/*      $OpenBSD: eexp.c,v 1.1 2011/07/02 18:11:01 martynas Exp $       */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                                      xexp.c          */
+/* exponential function check routine */
+/* by Stephen L. Moshier. */
+
+
+#include "ehead.h"
+
+void eexp( x, y )
+unsigned short *x, *y;
+{
+unsigned short num[NE], den[NE], x2[NE];
+long i;
+unsigned short sign, expchk;
+
+/* range reduction theory: x = i + f, 0<=f<1;
+ * e**x = e**i * e**f 
+ * e**i = 2**(i/log 2).
+ * Let i/log2 = i1 + f1, 0<=f1<1.
+ * Then e**i = 2**i1 * 2**f1, so
+ * e**x = 2**i1 * e**(log 2 * f1) * e**f.
+ */
+if( ecmp(x, ezero) == 0 )
+        {
+        emov( eone, y );
+        return;
+        }
+emov(x, x2);
+expchk = x2[NE-1];
+sign = expchk & 0x8000;
+x2[NE-1] &= 0x7fff;
+
+/* Test for excessively large argument */
+expchk &= 0x7fff;
+if( expchk > (EXONE + 15) )
+        {
+        eclear( y );
+        if( sign == 0 )
+                einfin( y );
+        return;
+        }
+
+eifrac( x2, &i, num );          /* x = i + f            */
+
+if( i != 0 )
+ {
+ ltoe( &i, den );               /* floating point i     */
+ ediv( elog2, den, den );       /* i/log 2              */
+ eifrac( den, &i, den );        /* i/log 2  =  i1 + f1  */
+ emul( elog2, den, den );       /* log 2 * f1           */
+ eadd( den, num, x2 );          /* log 2 * f1  + f      */
+ }
+
+/*x2[NE-1] -= 1;*/
+eldexp( x2, -1L, x2 ); /* divide by 2 */
+etanh( x2, x2 );        /* tanh( x/2 )                  */
+eadd( x2, eone, num );  /* 1 + tanh                     */
+eneg( x2 );
+eadd( x2, eone, den );  /* 1 - tanh                     */
+ediv( den, num, y );    /* (1 + tanh)/(1 - tanh)        */
+
+/*y[NE-1] += i;*/
+if( sign )
+        {
+        ediv( y, eone, y );
+        i = -i;
+        }
+eldexp( y, i, y );      /* multiply by 2**i */
+}
diff --git a/src/regress/lib/libc/cephes/ehead.h b/src/regress/lib/libc/cephes/ehead.h
new file mode 100644
index 0000000000..009bcf89cc
--- /dev/null
+++ b/src/regress/lib/libc/cephes/ehead.h
@@ -0,0 +1,59 @@
+/*      $OpenBSD: ehead.h,v 1.1 2011/07/02 18:11:01 martynas Exp $      */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* Include file for extended precision arithmetic programs.
+ */
+
+/* Number of 16 bit words in external x type format */
+#define NE 10
+
+/* Number of 16 bit words in internal format */
+#define NI (NE+3)
+
+/* Array offset to exponent */
+#define E 1
+
+/* Array offset to high guard word */
+#define M 2
+
+/* Number of bits of precision */
+#define NBITS ((NI-4)*16)
+
+/* Maximum number of decimal digits in ASCII conversion
+ * = NBITS*log10(2)
+ */
+#define NDEC (NBITS*8/27)
+
+/* The exponent of 1.0 */
+#define EXONE (0x3fff)
+
+void eadd(), esub(), emul(), ediv();
+int ecmp(), enormlz(), eshift();
+void eshup1(), eshup8(), eshup6(), eshdn1(), eshdn8(), eshdn6();
+void eabs(), eneg(), emov(), eclear(), einfin(), efloor();
+void eldexp(), efrexp(), eifrac(), ltoe();
+void esqrt(), elog(), eexp(), etanh(), epow();
+void asctoe(), asctoe24(), asctoe53(), asctoe64();
+void etoasc(), e24toasc(), e53toasc(), e64toasc();
+void etoe64(), etoe53(), etoe24(), e64toe(), e53toe(), e24toe();
+int mtherr();
+extern unsigned short ezero[], ehalf[], eone[], etwo[];
+extern unsigned short elog2[], esqrt2[];
+
+
+/* by Stephen L. Moshier. */
diff --git a/src/regress/lib/libc/cephes/elog.c b/src/regress/lib/libc/cephes/elog.c
new file mode 100644
index 0000000000..079cc754f4
--- /dev/null
+++ b/src/regress/lib/libc/cephes/elog.c
@@ -0,0 +1,110 @@
+/*      $OpenBSD: elog.c,v 1.1 2011/07/02 18:11:01 martynas Exp $       */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                              xlog.c  */
+/* natural logarithm */
+/* by Stephen L. Moshier. */
+
+#include "mconf.h"
+#include "ehead.h"
+
+
+
+void elog( x, y )
+unsigned short *x, *y;
+{
+unsigned short xx[NE], z[NE], a[NE], b[NE], t[NE], qj[NE];
+long ex;
+int fex;
+
+
+if( x[NE-1] & (unsigned short )0x8000 )
+        {
+        eclear(y);
+        mtherr( "elog", DOMAIN );
+        return;
+        }
+if( ecmp( x, ezero ) == 0 )
+        {
+        einfin( y );
+        eneg(y);
+        mtherr( "elog", SING );
+        return;
+        }
+if( ecmp( x, eone ) == 0 )
+        {
+        eclear( y );
+        return;
+        }
+
+/* range reduction: log x = log( 2**ex * m ) = ex * log2 + log m */
+efrexp( x, &fex, xx );
+/*
+emov(x, xx );
+ex = xx[NX-1] & 0x7fff;
+ex -= 0x3ffe;
+xx[NX-1] = 0x3ffe;
+*/
+
+/* Adjust range to 1/sqrt(2), sqrt(2) */
+esqrt2[NE-1] -= 1;
+if( ecmp( xx, esqrt2 ) < 0 )
+        {
+        fex -= 1;
+        emul( xx, etwo, xx );
+        }
+esqrt2[NE-1] += 1;
+
+esub( eone, xx, a );
+if( a[NE-1] == 0 )
+        {
+        eclear( y );
+        goto logdon;
+        }
+eadd( eone, xx, b );
+ediv( b, a, y );        /* store (x-1)/(x+1) in y */
+
+emul( y, y, z );
+
+emov( eone, a );
+emov( eone, b );
+emov( eone, qj );
+do
+        {
+        eadd( etwo, qj, qj );   /* 2 * i + 1            */
+        emul( z, a, a );
+        ediv( qj, a, t );
+        eadd( t, b, b );
+        }
+while( ((b[NE-1] & 0x7fff) - (t[NE-1] & 0x7fff)) < NBITS );
+
+
+emul( b, y, y );
+emul( y, etwo, y );
+
+logdon:
+
+/* now add log of 2**ex */
+if( fex != 0 )
+        {
+        ex = fex;
+        ltoe( &ex, b );
+        emul( elog2, b, b );
+        eadd( b, y, y );
+        }
+}
diff --git a/src/regress/lib/libc/cephes/epow.c b/src/regress/lib/libc/cephes/epow.c
new file mode 100644
index 0000000000..646268fce7
--- /dev/null
+++ b/src/regress/lib/libc/cephes/epow.c
@@ -0,0 +1,187 @@
+/*      $OpenBSD: epow.c,v 1.1 2011/07/02 18:11:01 martynas Exp $       */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                              epow.c  */
+/*  power function: z = x**y */
+/*  by Stephen L. Moshier. */
+
+
+#include "ehead.h"
+
+extern int rndprc;
+void epowi();
+
+void epow( x, y, z )
+unsigned short *x, *y, *z;
+{
+unsigned short w[NE];
+int rndsav;
+long li;
+
+efloor( y, w );
+if( ecmp(y,w) == 0 )
+        {
+        eifrac( y, &li, w );
+        if( li < 0 )
+                li = -li;
+        if( (li < 0x7fffffff) && (li != 0x80000000) )
+                {
+                epowi( x, y, z );
+                return;
+                }
+        }
+/* z = exp( y * log(x) ) */
+rndsav = rndprc;
+rndprc = NBITS;
+elog( x, w );
+emul( y, w, w );
+eexp( w, z );
+rndprc = rndsav;
+emul( eone, z, z );
+}
+
+
+/* y is integer valued. */
+
+void epowi( x, y, z )
+unsigned short x[], y[], z[];
+{
+unsigned short w[NE];
+long li, lx;
+unsigned long lu;
+int rndsav;
+unsigned short signx;
+/* unsigned short signy; */
+
+rndsav = rndprc;
+eifrac( y, &li, w );
+if( li < 0 )
+        lx = -li;
+else
+        lx = li;
+
+if( (lx == 0x7fffffff) || (lx == 0x80000000) )
+        {
+        epow( x, y, z );
+        goto done;
+        }
+
+if( (x[NE-1] & (unsigned short )0x7fff) == 0 )
+        {
+        if( li == 0 )
+                {
+                emov( eone, z );
+                return;
+                }
+        else if( li < 0 )
+                {
+                einfin( z );
+                return;
+                }
+        else
+                {
+                eclear( z );
+                return;
+                }
+        }
+
+if( li == 0L )
+        {
+        emov( eone, z );
+        return;
+        }
+
+emov( x, w );
+signx = w[NE-1] & (unsigned short )0x8000;
+w[NE-1] &= (unsigned short )0x7fff;
+
+/* Overflow detection */
+/*
+lx = li * (w[NE-1] - 0x3fff);
+if( lx > 16385L )
+        {
+        einfin( z );
+        mtherr( "epowi", OVERFLOW );
+        goto done;
+        }
+if( lx < -16450L )
+        {
+        eclear( z );
+        return;
+        }
+*/
+rndprc = NBITS;
+
+if( li < 0 )
+        {
+        lu = (unsigned int )( -li );
+/*      signy = 0xffff;*/
+        ediv( w, eone, w );
+        }
+else
+        {
+        lu = (unsigned int )li;
+/*      signy = 0;*/
+        }
+
+/* First bit of the power */
+if( lu & 1 )
+        {
+        emov( w, z );
+        }       
+else
+        {
+        emov( eone, z );
+        signx = 0;
+        }
+
+
+lu >>= 1;
+while( lu != 0L )
+        {
+        emul( w, w, w );        /* arg to the 2-to-the-kth power */
+        if( lu & 1L )   /* if that bit is set, then include in product */
+                emul( w, z, z );
+        lu >>= 1;
+        }
+
+
+done:
+
+if( signx )
+        eneg( z ); /* odd power of negative number */
+
+/*
+if( signy )
+        {
+        if( ecmp( z, ezero ) != 0 )
+                {
+                ediv( z, eone, z );
+                }
+        else
+                {
+                einfin( z );
+                printf( "epowi OVERFLOW\n" );
+                }
+        }
+*/
+rndprc = rndsav;
+emul( eone, z, z );
+}
+
+
diff --git a/src/regress/lib/libc/cephes/etanh.c b/src/regress/lib/libc/cephes/etanh.c
new file mode 100644
index 0000000000..4ac5ff1c21
--- /dev/null
+++ b/src/regress/lib/libc/cephes/etanh.c
@@ -0,0 +1,70 @@
+/*      $OpenBSD: etanh.c,v 1.1 2011/07/02 18:11:01 martynas Exp $      */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                                      xtanh.c         */
+/* hyperbolic tangent check routine */
+/* this subroutine is used by the exponential function routine */
+/* by Stephen L. Moshier. */
+
+
+
+#include "ehead.h"
+
+
+void etanh( x, y )
+unsigned short *x, *y;
+{
+unsigned short e[NE], r[NE], j[NE], xx[NE], m2[NE];
+short i, n;
+long lj;
+
+emov( x, r );
+r[NE-1] &= (unsigned short )0x7fff;
+if( ecmp(r, eone) >= 0 )
+        {
+/* tanh(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))
+ * Note eexp() calls xtanh, but with an argument less than (1 + log 2)/2.
+ */
+        eexp( r, e );
+        ediv( e, eone, r );
+        esub( r, e, xx );
+        eadd( r, e, j );
+        ediv( j, xx, y );
+        return;
+        }
+
+emov( etwo, m2 );
+eneg( m2 );
+
+n = NBITS/8;    /* Number of terms to do in the continued fraction */
+lj = 2 * n + 1;
+ltoe( &lj, j );
+
+emov( j, e );
+emul( x, x, xx );
+
+/* continued fraction */
+for( i=0; i<n; i++)
+        {
+        ediv( e, xx, r );
+        eadd( m2, j, j );
+        eadd( r, j, e );
+        }
+
+ediv( e, x, y );
+}
diff --git a/src/regress/lib/libc/cephes/etodec.c b/src/regress/lib/libc/cephes/etodec.c
new file mode 100644
index 0000000000..a15845efb6
--- /dev/null
+++ b/src/regress/lib/libc/cephes/etodec.c
@@ -0,0 +1,199 @@
+/*      $OpenBSD: etodec.c,v 1.1 2011/07/02 18:11:01 martynas Exp $     */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "ehead.h"
+void emovi(), emovo(), ecleaz(), eshdn8(), emdnorm();
+void todec();
+/*
+;       convert DEC double precision to e type
+;       double d;
+;       short e[NE];
+;       dectoe( &d, e );
+*/
+void dectoe( d, e )
+unsigned short *d;
+unsigned short *e;
+{
+unsigned short y[NI];
+register unsigned short r, *p;
+
+ecleaz(y);              /* start with a zero */
+p = y;                  /* point to our number */
+r = *d;                 /* get DEC exponent word */
+if( *d & (unsigned int )0x8000 )
+        *p = 0xffff;    /* fill in our sign */
+++p;                    /* bump pointer to our exponent word */
+r &= 0x7fff;            /* strip the sign bit */
+if( r == 0 )            /* answer = 0 if high order DEC word = 0 */
+        goto done;
+
+
+r >>= 7;        /* shift exponent word down 7 bits */
+r += EXONE - 0201;      /* subtract DEC exponent offset */
+                        /* add our e type exponent offset */
+*p++ = r;       /* to form our exponent */
+
+r = *d++;       /* now do the high order mantissa */
+r &= 0177;      /* strip off the DEC exponent and sign bits */
+r |= 0200;      /* the DEC understood high order mantissa bit */
+*p++ = r;       /* put result in our high guard word */
+
+*p++ = *d++;    /* fill in the rest of our mantissa */
+*p++ = *d++;
+*p = *d;
+
+eshdn8(y);      /* shift our mantissa down 8 bits */
+done:
+emovo( y, e );
+}
+
+
+
+/*
+;       convert e type to DEC double precision
+;       double d;
+;       short e[NE];
+;       etodec( e, &d );
+*/
+#if 0
+static unsigned short decbit[NI] = {0,0,0,0,0,0,0200,0};
+void etodec( x, d )
+unsigned short *x, *d;
+{
+unsigned short xi[NI];
+register unsigned short r;
+int i, j;
+
+emovi( x, xi );
+*d = 0;
+if( xi[0] != 0 )
+        *d = 0100000;
+r = xi[E];
+if( r < (EXONE - 128) )
+        goto zout;
+i = xi[M+4];
+if( (i & 0200) != 0 )
+        {
+        if( (i & 0377) == 0200 )
+                {
+                if( (i & 0400) != 0 )
+                        {
+                /* check all less significant bits */
+                        for( j=M+5; j<NI; j++ )
+                                {
+                                if( xi[j] != 0 )
+                                        goto yesrnd;
+                                }
+                        }
+                goto nornd;
+                }
+yesrnd:
+        eaddm( decbit, xi );
+        r -= enormlz(xi);
+        }
+
+nornd:
+
+r -= EXONE;
+r += 0201;
+if( r < 0 )
+        {
+zout:
+        *d++ = 0;
+        *d++ = 0;
+        *d++ = 0;
+        *d++ = 0;
+        return;
+        }
+if( r >= 0377 )
+        {
+        *d++ = 077777;
+        *d++ = -1;
+        *d++ = -1;
+        *d++ = -1;
+        return;
+        }
+r &= 0377;
+r <<= 7;
+eshup8( xi );
+xi[M] &= 0177;
+r |= xi[M];
+*d++ |= r;
+*d++ = xi[M+1];
+*d++ = xi[M+2];
+*d++ = xi[M+3];
+}
+#else
+
+extern int rndprc;
+
+void etodec( x, d )
+unsigned short *x, *d;
+{
+unsigned short xi[NI];
+long exp;
+int rndsav;
+
+emovi( x, xi );
+exp = (long )xi[E] - (EXONE - 0201); /* adjust exponent for offsets */
+/* round off to nearest or even */
+rndsav = rndprc;
+rndprc = 56;
+emdnorm( xi, 0, 0, exp, 64 );
+rndprc = rndsav;
+todec( xi, d );
+}
+
+void todec( x, y )
+unsigned short *x, *y;
+{
+unsigned short i;
+unsigned short *p;
+
+p = x;
+*y = 0;
+if( *p++ )
+        *y = 0100000;
+i = *p++;
+if( i == 0 )
+        {
+        *y++ = 0;
+        *y++ = 0;
+        *y++ = 0;
+        *y++ = 0;
+        return;
+        }
+if( i > 0377 )
+        {
+        *y++ |= 077777;
+        *y++ = 0xffff;
+        *y++ = 0xffff;
+        *y++ = 0xffff;
+        return;
+        }
+i &= 0377;
+i <<= 7;
+eshup8( x );
+x[M] &= 0177;
+i |= x[M];
+*y++ |= i;
+*y++ = x[M+1];
+*y++ = x[M+2];
+*y++ = x[M+3];
+}
+#endif
diff --git a/src/regress/lib/libc/cephes/ieee.c b/src/regress/lib/libc/cephes/ieee.c
new file mode 100644
index 0000000000..e2b8aa7b99
--- /dev/null
+++ b/src/regress/lib/libc/cephes/ieee.c
@@ -0,0 +1,4153 @@
+/*      $OpenBSD: ieee.c,v 1.1 2011/07/02 18:11:01 martynas Exp $       */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                                      ieee.c
+ *
+ *    Extended precision IEEE binary floating point arithmetic routines
+ *
+ * Numbers are stored in C language as arrays of 16-bit unsigned
+ * short integers.  The arguments of the routines are pointers to
+ * the arrays.
+ *
+ *
+ * External e type data structure, simulates Intel 8087 chip
+ * temporary real format but possibly with a larger significand:
+ *
+ *      NE-1 significand words  (least significant word first,
+ *                               most significant bit is normally set)
+ *      exponent                (value = EXONE for 1.0,
+ *                              top bit is the sign)
+ *
+ *
+ * Internal data structure of a number (a "word" is 16 bits):
+ *
+ * ei[0]        sign word       (0 for positive, 0xffff for negative)
+ * ei[1]        biased exponent (value = EXONE for the number 1.0)
+ * ei[2]        high guard word (always zero after normalization)
+ * ei[3]
+ * to ei[NI-2]  significand     (NI-4 significand words,
+ *                               most significant word first,
+ *                               most significant bit is set)
+ * ei[NI-1]     low guard word  (0x8000 bit is rounding place)
+ *
+ *
+ *
+ *              Routines for external format numbers
+ *
+ *      asctoe( string, e )     ASCII string to extended double e type
+ *      asctoe64( string, &d )  ASCII string to long double
+ *      asctoe53( string, &d )  ASCII string to double
+ *      asctoe24( string, &f )  ASCII string to single
+ *      asctoeg( string, e, prec ) ASCII string to specified precision
+ *      e24toe( &f, e )         IEEE single precision to e type
+ *      e53toe( &d, e )         IEEE double precision to e type
+ *      e64toe( &d, e )         IEEE long double precision to e type
+ *      eabs(e)                 absolute value
+ *      eadd( a, b, c )         c = b + a
+ *      eclear(e)               e = 0
+ *      ecmp (a, b)             Returns 1 if a > b, 0 if a == b,
+ *                              -1 if a < b, -2 if either a or b is a NaN.
+ *      ediv( a, b, c )         c = b / a
+ *      efloor( a, b )          truncate to integer, toward -infinity
+ *      efrexp( a, exp, s )     extract exponent and significand
+ *      eifrac( e, &l, frac )   e to long integer and e type fraction
+ *      euifrac( e, &l, frac )  e to unsigned long integer and e type fraction
+ *      einfin( e )             set e to infinity, leaving its sign alone
+ *      eldexp( a, n, b )       multiply by 2**n
+ *      emov( a, b )            b = a
+ *      emul( a, b, c )         c = b * a
+ *      eneg(e)                 e = -e
+ *      eround( a, b )          b = nearest integer value to a
+ *      esub( a, b, c )         c = b - a
+ *      e24toasc( &f, str, n )  single to ASCII string, n digits after decimal
+ *      e53toasc( &d, str, n )  double to ASCII string, n digits after decimal
+ *      e64toasc( &d, str, n )  long double to ASCII string
+ *      etoasc( e, str, n )     e to ASCII string, n digits after decimal
+ *      etoe24( e, &f )         convert e type to IEEE single precision
+ *      etoe53( e, &d )         convert e type to IEEE double precision
+ *      etoe64( e, &d )         convert e type to IEEE long double precision
+ *      ltoe( &l, e )           long (32 bit) integer to e type
+ *      ultoe( &l, e )          unsigned long (32 bit) integer to e type
+ *      eisneg( e )             1 if sign bit of e != 0, else 0
+ *      eisinf( e )             1 if e has maximum exponent (non-IEEE)
+ *                              or is infinite (IEEE)
+ *      eisnan( e )             1 if e is a NaN
+ *      esqrt( a, b )           b = square root of a
+ *
+ *
+ *              Routines for internal format numbers
+ *
+ *      eaddm( ai, bi )         add significands, bi = bi + ai
+ *      ecleaz(ei)              ei = 0
+ *      ecleazs(ei)             set ei = 0 but leave its sign alone
+ *      ecmpm( ai, bi )         compare significands, return 1, 0, or -1
+ *      edivm( ai, bi )         divide  significands, bi = bi / ai
+ *      emdnorm(ai,l,s,exp)     normalize and round off
+ *      emovi( a, ai )          convert external a to internal ai
+ *      emovo( ai, a )          convert internal ai to external a
+ *      emovz( ai, bi )         bi = ai, low guard word of bi = 0
+ *      emulm( ai, bi )         multiply significands, bi = bi * ai
+ *      enormlz(ei)             left-justify the significand
+ *      eshdn1( ai )            shift significand and guards down 1 bit
+ *      eshdn8( ai )            shift down 8 bits
+ *      eshdn6( ai )            shift down 16 bits
+ *      eshift( ai, n )         shift ai n bits up (or down if n < 0)
+ *      eshup1( ai )            shift significand and guards up 1 bit
+ *      eshup8( ai )            shift up 8 bits
+ *      eshup6( ai )            shift up 16 bits
+ *      esubm( ai, bi )         subtract significands, bi = bi - ai
+ *
+ *
+ * The result is always normalized and rounded to NI-4 word precision
+ * after each arithmetic operation.
+ *
+ * Exception flags are NOT fully supported.
+ *
+ * Define INFINITY in mconf.h for support of infinity; otherwise a
+ * saturation arithmetic is implemented.
+ *
+ * Define NANS for support of Not-a-Number items; otherwise the
+ * arithmetic will never produce a NaN output, and might be confused
+ * by a NaN input.
+ * If NaN's are supported, the output of ecmp(a,b) is -2 if
+ * either a or b is a NaN. This means asking if(ecmp(a,b) < 0)
+ * may not be legitimate. Use if(ecmp(a,b) == -1) for less-than
+ * if in doubt.
+ * Signaling NaN's are NOT supported; they are treated the same
+ * as quiet NaN's.
+ *
+ * Denormals are always supported here where appropriate (e.g., not
+ * for conversion to DEC numbers).
+ */
+
+/*
+ * Revision history:
+ *
+ *  5 Jan 84    PDP-11 assembly language version
+ *  2 Mar 86    fixed bug in asctoq()
+ *  6 Dec 86    C language version
+ * 30 Aug 88    100 digit version, improved rounding
+ * 15 May 92    80-bit long double support
+ *
+ * Author:  S. L. Moshier.
+ */
+
+#include <stdio.h>
+#include "mconf.h"
+#include "ehead.h"
+
+/* Change UNK into something else. */
+#ifdef UNK
+#undef UNK
+#if BIGENDIAN
+#define MIEEE 1
+#else
+#define IBMPC 1
+#endif
+#endif
+
+/* NaN's require infinity support. */
+#ifdef NANS
+#ifndef INFINITY
+#define INFINITY
+#endif
+#endif
+
+/* This handles 64-bit long ints. */
+#define LONGBITS (8 * sizeof(long))
+
+/* Control register for rounding precision.
+ * This can be set to 80 (if NE=6), 64, 56, 53, or 24 bits.
+ */
+int rndprc = NBITS;
+extern int rndprc;
+
+void eaddm(), esubm(), emdnorm(), asctoeg(), enan();
+static void toe24(), toe53(), toe64(), toe113();
+void eremain(), einit(), eiremain();
+int ecmpm(), edivm(), emulm(), eisneg(), eisinf();
+void emovi(), emovo(), emovz(), ecleaz(), eadd1();
+void etodec(), todec(), dectoe();
+int eisnan(), eiisnan();
+
+
+
+void einit()
+{
+}
+
+/*
+; Clear out entire external format number.
+;
+; unsigned short x[];
+; eclear( x );
+*/
+
+void eclear( x )
+register unsigned short *x;
+{
+register int i;
+
+for( i=0; i<NE; i++ )
+        *x++ = 0;
+}
+
+
+
+/* Move external format number from a to b.
+ *
+ * emov( a, b );
+ */
+
+void emov( a, b )
+register unsigned short *a, *b;
+{
+register int i;
+
+for( i=0; i<NE; i++ )
+        *b++ = *a++;
+}
+
+
+/*
+;       Absolute value of external format number
+;
+;       short x[NE];
+;       eabs( x );
+*/
+
+void eabs(x)
+unsigned short x[];     /* x is the memory address of a short */
+{
+
+x[NE-1] &= 0x7fff; /* sign is top bit of last word of external format */
+}
+
+
+
+
+/*
+;       Negate external format number
+;
+;       unsigned short x[NE];
+;       eneg( x );
+*/
+
+void eneg(x)
+unsigned short x[];
+{
+
+#ifdef NANS
+if( eisnan(x) )
+        return;
+#endif
+x[NE-1] ^= 0x8000; /* Toggle the sign bit */
+}
+
+
+
+/* Return 1 if external format number is negative,
+ * else return zero.
+ */
+int eisneg(x)
+unsigned short x[];
+{
+
+#ifdef NANS
+if( eisnan(x) )
+        return( 0 );
+#endif
+if( x[NE-1] & 0x8000 )
+        return( 1 );
+else
+        return( 0 );
+}
+
+
+/* Return 1 if external format number has maximum possible exponent,
+ * else return zero.
+ */
+int eisinf(x)
+unsigned short x[];
+{
+
+if( (x[NE-1] & 0x7fff) == 0x7fff )
+        {
+#ifdef NANS
+        if( eisnan(x) )
+                return( 0 );
+#endif
+        return( 1 );
+        }
+else
+        return( 0 );
+}
+
+/* Check if e-type number is not a number.
+ */
+int eisnan(x)
+unsigned short x[];
+{
+
+#ifdef NANS
+int i;
+/* NaN has maximum exponent */
+if( (x[NE-1] & 0x7fff) != 0x7fff )
+        return (0);
+/* ... and non-zero significand field. */
+for( i=0; i<NE-1; i++ )
+        {
+        if( *x++ != 0 )
+                return (1);
+        }
+#endif
+return (0);
+}
+
+/*
+; Fill entire number, including exponent and significand, with
+; largest possible number.  These programs implement a saturation
+; value that is an ordinary, legal number.  A special value
+; "infinity" may also be implemented; this would require tests
+; for that value and implementation of special rules for arithmetic
+; operations involving inifinity.
+*/
+
+void einfin(x)
+register unsigned short *x;
+{
+register int i;
+
+#ifdef INFINITY
+for( i=0; i<NE-1; i++ )
+        *x++ = 0;
+*x |= 32767;
+#else
+for( i=0; i<NE-1; i++ )
+        *x++ = 0xffff;
+*x |= 32766;
+if( rndprc < NBITS )
+        {
+        if (rndprc == 113)
+                {
+                *(x - 9) = 0;
+                *(x - 8) = 0;
+                }
+        if( rndprc == 64 )
+                {
+                *(x-5) = 0;
+                }
+        if( rndprc == 53 )
+                {
+                *(x-4) = 0xf800;
+                }
+        else
+                {
+                *(x-4) = 0;
+                *(x-3) = 0;
+                *(x-2) = 0xff00;
+                }
+        }
+#endif
+}
+
+
+
+/* Move in external format number,
+ * converting it to internal format.
+ */
+void emovi( a, b )
+unsigned short *a, *b;
+{
+register unsigned short *p, *q;
+int i;
+
+q = b;
+p = a + (NE-1); /* point to last word of external number */
+/* get the sign bit */
+if( *p & 0x8000 )
+        *q++ = 0xffff;
+else
+        *q++ = 0;
+/* get the exponent */
+*q = *p--;
+*q++ &= 0x7fff; /* delete the sign bit */
+#ifdef INFINITY
+if( (*(q-1) & 0x7fff) == 0x7fff )
+        {
+#ifdef NANS
+        if( eisnan(a) )
+                {
+                *q++ = 0;
+                for( i=3; i<NI; i++ )
+                        *q++ = *p--;
+                return;
+                }
+#endif
+        for( i=2; i<NI; i++ )
+                *q++ = 0;
+        return;
+        }
+#endif
+/* clear high guard word */
+*q++ = 0;
+/* move in the significand */
+for( i=0; i<NE-1; i++ )
+        *q++ = *p--;
+/* clear low guard word */
+*q = 0;
+}
+
+
+/* Move internal format number out,
+ * converting it to external format.
+ */
+void emovo( a, b )
+unsigned short *a, *b;
+{
+register unsigned short *p, *q;
+unsigned short i;
+
+p = a;
+q = b + (NE-1); /* point to output exponent */
+/* combine sign and exponent */
+i = *p++;
+if( i )
+        *q-- = *p++ | 0x8000;
+else
+        *q-- = *p++;
+#ifdef INFINITY
+if( *(p-1) == 0x7fff )
+        {
+#ifdef NANS
+        if( eiisnan(a) )
+                {
+                enan( b, NBITS );
+                return;
+                }
+#endif
+        einfin(b);
+        return;
+        }
+#endif
+/* skip over guard word */
+++p;
+/* move the significand */
+for( i=0; i<NE-1; i++ )
+        *q-- = *p++;
+}
+
+
+
+
+/* Clear out internal format number.
+ */
+
+void ecleaz( xi )
+register unsigned short *xi;
+{
+register int i;
+
+for( i=0; i<NI; i++ )
+        *xi++ = 0;
+}
+
+/* same, but don't touch the sign. */
+
+void ecleazs( xi )
+register unsigned short *xi;
+{
+register int i;
+
+++xi;
+for(i=0; i<NI-1; i++)
+        *xi++ = 0;
+}
+
+
+
+
+/* Move internal format number from a to b.
+ */
+void emovz( a, b )
+register unsigned short *a, *b;
+{
+register int i;
+
+for( i=0; i<NI-1; i++ )
+        *b++ = *a++;
+/* clear low guard word */
+*b = 0;
+}
+
+/* Return nonzero if internal format number is a NaN.
+ */
+
+int eiisnan (x)
+unsigned short x[];
+{
+int i;
+
+if( (x[E] & 0x7fff) == 0x7fff )
+        {
+        for( i=M+1; i<NI; i++ )
+                {
+                if( x[i] != 0 )
+                        return(1);
+                }
+        }
+return(0);
+}
+
+#ifdef INFINITY
+/* Return nonzero if internal format number is infinite. */
+
+static int 
+eiisinf (x)
+     unsigned short x[];
+{
+
+#ifdef NANS
+  if (eiisnan (x))
+    return (0);
+#endif
+  if ((x[E] & 0x7fff) == 0x7fff)
+    return (1);
+  return (0);
+}
+#endif
+
+/*
+;       Compare significands of numbers in internal format.
+;       Guard words are included in the comparison.
+;
+;       unsigned short a[NI], b[NI];
+;       cmpm( a, b );
+;
+;       for the significands:
+;       returns +1 if a > b
+;                0 if a == b
+;               -1 if a < b
+*/
+int ecmpm( a, b )
+register unsigned short *a, *b;
+{
+int i;
+
+a += M; /* skip up to significand area */
+b += M;
+for( i=M; i<NI; i++ )
+        {
+        if( *a++ != *b++ )
+                goto difrnt;
+        }
+return(0);
+
+difrnt:
+if( *(--a) > *(--b) )
+        return(1);
+else
+        return(-1);
+}
+
+
+/*
+;       Shift significand down by 1 bit
+*/
+
+void eshdn1(x)
+register unsigned short *x;
+{
+register unsigned short bits;
+int i;
+
+x += M; /* point to significand area */
+
+bits = 0;
+for( i=M; i<NI; i++ )
+        {
+        if( *x & 1 )
+                bits |= 1;
+        *x >>= 1;
+        if( bits & 2 )
+                *x |= 0x8000;
+        bits <<= 1;
+        ++x;
+        }       
+}
+
+
+
+/*
+;       Shift significand up by 1 bit
+*/
+
+void eshup1(x)
+register unsigned short *x;
+{
+register unsigned short bits;
+int i;
+
+x += NI-1;
+bits = 0;
+
+for( i=M; i<NI; i++ )
+        {
+        if( *x & 0x8000 )
+                bits |= 1;
+        *x <<= 1;
+        if( bits & 2 )
+                *x |= 1;
+        bits <<= 1;
+        --x;
+        }
+}
+
+
+
+/*
+;       Shift significand down by 8 bits
+*/
+
+void eshdn8(x)
+register unsigned short *x;
+{
+register unsigned short newbyt, oldbyt;
+int i;
+
+x += M;
+oldbyt = 0;
+for( i=M; i<NI; i++ )
+        {
+        newbyt = *x << 8;
+        *x >>= 8;
+        *x |= oldbyt;
+        oldbyt = newbyt;
+        ++x;
+        }
+}
+
+/*
+;       Shift significand up by 8 bits
+*/
+
+void eshup8(x)
+register unsigned short *x;
+{
+int i;
+register unsigned short newbyt, oldbyt;
+
+x += NI-1;
+oldbyt = 0;
+
+for( i=M; i<NI; i++ )
+        {
+        newbyt = *x >> 8;
+        *x <<= 8;
+        *x |= oldbyt;
+        oldbyt = newbyt;
+        --x;
+        }
+}
+
+/*
+;       Shift significand up by 16 bits
+*/
+
+void eshup6(x)
+register unsigned short *x;
+{
+int i;
+register unsigned short *p;
+
+p = x + M;
+x += M + 1;
+
+for( i=M; i<NI-1; i++ )
+        *p++ = *x++;
+
+*p = 0;
+}
+
+/*
+;       Shift significand down by 16 bits
+*/
+
+void eshdn6(x)
+register unsigned short *x;
+{
+int i;
+register unsigned short *p;
+
+x += NI-1;
+p = x + 1;
+
+for( i=M; i<NI-1; i++ )
+        *(--p) = *(--x);
+
+*(--p) = 0;
+}
+
+/*
+;       Add significands
+;       x + y replaces y
+*/
+
+void eaddm( x, y )
+unsigned short *x, *y;
+{
+register unsigned long a;
+int i;
+unsigned int carry;
+
+x += NI-1;
+y += NI-1;
+carry = 0;
+for( i=M; i<NI; i++ )
+        {
+        a = (unsigned long )(*x) + (unsigned long )(*y) + carry;
+        if( a & 0x10000 )
+                carry = 1;
+        else
+                carry = 0;
+        *y = (unsigned short )a;
+        --x;
+        --y;
+        }
+}
+
+/*
+;       Subtract significands
+;       y - x replaces y
+*/
+
+void esubm( x, y )
+unsigned short *x, *y;
+{
+unsigned long a;
+int i;
+unsigned int carry;
+
+x += NI-1;
+y += NI-1;
+carry = 0;
+for( i=M; i<NI; i++ )
+        {
+        a = (unsigned long )(*y) - (unsigned long )(*x) - carry;
+        if( a & 0x10000 )
+                carry = 1;
+        else
+                carry = 0;
+        *y = (unsigned short )a;
+        --x;
+        --y;
+        }
+}
+
+
+/* Divide significands */
+
+static unsigned short equot[NI] = {0}; /* was static */
+
+#if 0
+int edivm( den, num )
+unsigned short den[], num[];
+{
+int i;
+register unsigned short *p, *q;
+unsigned short j;
+
+p = &equot[0];
+*p++ = num[0];
+*p++ = num[1];
+
+for( i=M; i<NI; i++ )
+        {
+        *p++ = 0;
+        }
+
+/* Use faster compare and subtraction if denominator
+ * has only 15 bits of significance.
+ */
+p = &den[M+2];
+if( *p++ == 0 )
+        {
+        for( i=M+3; i<NI; i++ )
+                {
+                if( *p++ != 0 )
+                        goto fulldiv;
+                }
+        if( (den[M+1] & 1) != 0 )
+                goto fulldiv;
+        eshdn1(num);
+        eshdn1(den);
+
+        p = &den[M+1];
+        q = &num[M+1];
+
+        for( i=0; i<NBITS+2; i++ )
+                {
+                if( *p <= *q )
+                        {
+                        *q -= *p;
+                        j = 1;
+                        }
+                else
+                        {
+                        j = 0;
+                        }
+                eshup1(equot);
+                equot[NI-2] |= j;
+                eshup1(num);
+                }
+        goto divdon;
+        }
+
+/* The number of quotient bits to calculate is
+ * NBITS + 1 scaling guard bit + 1 roundoff bit.
+ */
+fulldiv:
+
+p = &equot[NI-2];
+for( i=0; i<NBITS+2; i++ )
+        {
+        if( ecmpm(den,num) <= 0 )
+                {
+                esubm(den, num);
+                j = 1;  /* quotient bit = 1 */
+                }
+        else
+                j = 0;
+        eshup1(equot);
+        *p |= j;
+        eshup1(num);
+        }
+
+divdon:
+
+eshdn1( equot );
+eshdn1( equot );
+
+/* test for nonzero remainder after roundoff bit */
+p = &num[M];
+j = 0;
+for( i=M; i<NI; i++ )
+        {
+        j |= *p++;
+        }
+if( j )
+        j = 1;
+
+
+for( i=0; i<NI; i++ )
+        num[i] = equot[i];
+return( (int )j );
+}
+
+/* Multiply significands */
+int emulm( a, b )
+unsigned short a[], b[];
+{
+unsigned short *p, *q;
+int i, j, k;
+
+equot[0] = b[0];
+equot[1] = b[1];
+for( i=M; i<NI; i++ )
+        equot[i] = 0;
+
+p = &a[NI-2];
+k = NBITS;
+while( *p == 0 ) /* significand is not supposed to be all zero */
+        {
+        eshdn6(a);
+        k -= 16;
+        }
+if( (*p & 0xff) == 0 )
+        {
+        eshdn8(a);
+        k -= 8;
+        }
+
+q = &equot[NI-1];
+j = 0;
+for( i=0; i<k; i++ )
+        {
+        if( *p & 1 )
+                eaddm(b, equot);
+/* remember if there were any nonzero bits shifted out */
+        if( *q & 1 )
+                j |= 1;
+        eshdn1(a);
+        eshdn1(equot);
+        }
+
+for( i=0; i<NI; i++ )
+        b[i] = equot[i];
+
+/* return flag for lost nonzero bits */
+return(j);
+}
+
+#else
+
+/* Multiply significand of e-type number b
+by 16-bit quantity a, e-type result to c. */
+
+void m16m( a, b, c )
+unsigned short a;
+unsigned short b[], c[];
+{
+register unsigned short *pp;
+register unsigned long carry;
+unsigned short *ps;
+unsigned short p[NI];
+unsigned long aa, m;
+int i;
+
+aa = a;
+pp = &p[NI-2];
+*pp++ = 0;
+*pp = 0;
+ps = &b[NI-1];
+
+for( i=M+1; i<NI; i++ )
+        {
+        if( *ps == 0 )
+                {
+                --ps;
+                --pp;
+                *(pp-1) = 0;
+                }
+        else
+                {
+                m = (unsigned long) aa * *ps--;
+                carry = (m & 0xffff) + *pp;
+                *pp-- = (unsigned short )carry;
+                carry = (carry >> 16) + (m >> 16) + *pp;
+                *pp = (unsigned short )carry;
+                *(pp-1) = carry >> 16;
+                }
+        }
+for( i=M; i<NI; i++ )
+        c[i] = p[i];
+}
+
+
+/* Divide significands. Neither the numerator nor the denominator
+is permitted to have its high guard word nonzero.  */
+
+
+int edivm( den, num )
+unsigned short den[], num[];
+{
+int i;
+register unsigned short *p;
+unsigned long tnum;
+unsigned short j, tdenm, tquot;
+unsigned short tprod[NI+1];
+
+p = &equot[0];
+*p++ = num[0];
+*p++ = num[1];
+
+for( i=M; i<NI; i++ )
+        {
+        *p++ = 0;
+        }
+eshdn1( num );
+tdenm = den[M+1];
+for( i=M; i<NI; i++ )
+        {
+        /* Find trial quotient digit (the radix is 65536). */
+        tnum = (((unsigned long) num[M]) << 16) + num[M+1];
+
+        /* Do not execute the divide instruction if it will overflow. */
+        if( (tdenm * 0xffffL) < tnum )
+                tquot = 0xffff;
+        else
+                tquot = tnum / tdenm;
+
+                /* Prove that the divide worked. */
+/*
+        tcheck = (unsigned long )tquot * tdenm;
+        if( tnum - tcheck > tdenm )
+                tquot = 0xffff;
+*/
+        /* Multiply denominator by trial quotient digit. */
+        m16m( tquot, den, tprod );
+        /* The quotient digit may have been overestimated. */
+        if( ecmpm( tprod, num ) > 0 )
+                {
+                tquot -= 1;
+                esubm( den, tprod );
+                if( ecmpm( tprod, num ) > 0 )
+                        {
+                        tquot -= 1;
+                        esubm( den, tprod );
+                        }
+                }
+/*
+        if( ecmpm( tprod, num ) > 0 )
+                {
+                eshow( "tprod", tprod );
+                eshow( "num  ", num );
+                printf( "tnum = %08lx, tden = %04x, tquot = %04x\n",
+                         tnum, den[M+1], tquot );
+                }
+*/
+        esubm( tprod, num );
+/*
+        if( ecmpm( num, den ) >= 0 )
+                {
+                eshow( "num  ", num );
+                eshow( "den  ", den );
+                printf( "tnum = %08lx, tden = %04x, tquot = %04x\n",
+                         tnum, den[M+1], tquot );
+                }
+*/
+        equot[i] = tquot;
+        eshup6(num);
+        }
+/* test for nonzero remainder after roundoff bit */
+p = &num[M];
+j = 0;
+for( i=M; i<NI; i++ )
+        {
+        j |= *p++;
+        }
+if( j )
+        j = 1;
+
+for( i=0; i<NI; i++ )
+        num[i] = equot[i];
+
+return( (int )j );
+}
+
+
+
+/* Multiply significands */
+int emulm( a, b )
+unsigned short a[], b[];
+{
+unsigned short *p, *q;
+unsigned short pprod[NI];
+unsigned short j;
+int i;
+
+equot[0] = b[0];
+equot[1] = b[1];
+for( i=M; i<NI; i++ )
+        equot[i] = 0;
+
+j = 0;
+p = &a[NI-1];
+q = &equot[NI-1];
+for( i=M+1; i<NI; i++ )
+        {
+        if( *p == 0 )
+                {
+                --p;
+                }
+        else
+                {
+                m16m( *p--, b, pprod );
+                eaddm(pprod, equot);
+                }
+        j |= *q;
+        eshdn6(equot);
+        }
+
+for( i=0; i<NI; i++ )
+        b[i] = equot[i];
+
+/* return flag for lost nonzero bits */
+return( (int)j );
+}
+
+
+/*
+eshow(str, x)
+char *str;
+unsigned short *x;
+{
+int i;
+
+printf( "%s ", str );
+for( i=0; i<NI; i++ )
+        printf( "%04x ", *x++ );
+printf( "\n" );
+}
+*/
+#endif
+
+
+
+/*
+ * Normalize and round off.
+ *
+ * The internal format number to be rounded is "s".
+ * Input "lost" indicates whether the number is exact.
+ * This is the so-called sticky bit.
+ *
+ * Input "subflg" indicates whether the number was obtained
+ * by a subtraction operation.  In that case if lost is nonzero
+ * then the number is slightly smaller than indicated.
+ *
+ * Input "exp" is the biased exponent, which may be negative.
+ * the exponent field of "s" is ignored but is replaced by
+ * "exp" as adjusted by normalization and rounding.
+ *
+ * Input "rcntrl" is the rounding control.
+ */
+
+static int rlast = -1;
+static int rw = 0;
+static unsigned short rmsk = 0;
+static unsigned short rmbit = 0;
+static unsigned short rebit = 0;
+static int re = 0;
+static unsigned short rbit[NI] = {0,0,0,0,0,0,0,0};
+
+void emdnorm( s, lost, subflg, exp, rcntrl )
+unsigned short s[];
+int lost;
+int subflg;
+long exp;
+int rcntrl;
+{
+int i, j;
+unsigned short r;
+
+/* Normalize */
+j = enormlz( s );
+
+/* a blank significand could mean either zero or infinity. */
+#ifndef INFINITY
+if( j > NBITS )
+        {
+        ecleazs( s );
+        return;
+        }
+#endif
+exp -= j;
+#ifndef INFINITY
+if( exp >= 32767L )
+        goto overf;
+#else
+if( (j > NBITS) && (exp < 32767L) )
+        {
+        ecleazs( s );
+        return;
+        }
+#endif
+if( exp < 0L )
+        {
+        if( exp > (long )(-NBITS-1) )
+                {
+                j = (int )exp;
+                i = eshift( s, j );
+                if( i )
+                        lost = 1;
+                }
+        else
+                {
+                ecleazs( s );
+                return;
+                }
+        }
+/* Round off, unless told not to by rcntrl. */
+if( rcntrl == 0 )
+        goto mdfin;
+/* Set up rounding parameters if the control register changed. */
+if( rndprc != rlast )
+        {
+        ecleaz( rbit );
+        switch( rndprc )
+                {
+                default:
+                case NBITS:
+                        rw = NI-1; /* low guard word */
+                        rmsk = 0xffff;
+                        rmbit = 0x8000;
+                        rebit = 1;
+                        re = rw - 1;
+                        break;
+                case 113:
+                        rw = 10;
+                        rmsk = 0x7fff;
+                        rmbit = 0x4000;
+                        rebit = 0x8000;
+                        re = rw;
+                        break;
+                case 64:
+                        rw = 7;
+                        rmsk = 0xffff;
+                        rmbit = 0x8000;
+                        rebit = 1;
+                        re = rw-1;
+                        break;
+/* For DEC arithmetic */
+                case 56:
+                        rw = 6;
+                        rmsk = 0xff;
+                        rmbit = 0x80;
+                        rebit = 0x100;
+                        re = rw;
+                        break;
+                case 53:
+                        rw = 6;
+                        rmsk = 0x7ff;
+                        rmbit = 0x0400;
+                        rebit = 0x800;
+                        re = rw;
+                        break;
+                case 24:
+                        rw = 4;
+                        rmsk = 0xff;
+                        rmbit = 0x80;
+                        rebit = 0x100;
+                        re = rw;
+                        break;
+                }
+        rbit[re] = rebit;
+        rlast = rndprc;
+        }
+
+/* Shift down 1 temporarily if the data structure has an implied
+ * most significant bit and the number is denormal.
+ * For rndprc = 64 or NBITS, there is no implied bit.
+ * But Intel long double denormals lose one bit of significance even so.
+ */
+#ifdef IBMPC
+if( (exp <= 0) && (rndprc != NBITS) )
+#else
+if( (exp <= 0) && (rndprc != 64) && (rndprc != NBITS) )
+#endif
+        {
+        lost |= s[NI-1] & 1;
+        eshdn1(s);
+        }
+/* Clear out all bits below the rounding bit,
+ * remembering in r if any were nonzero.
+ */
+r = s[rw] & rmsk;
+if( rndprc < NBITS )
+        {
+        i = rw + 1;
+        while( i < NI )
+                {
+                if( s[i] )
+                        r |= 1;
+                s[i] = 0;
+                ++i;
+                }
+        }
+s[rw] &= ~rmsk;
+if( (r & rmbit) != 0 )
+        {
+        if( r == rmbit )
+                {
+                if( lost == 0 )
+                        { /* round to even */
+                        if( (s[re] & rebit) == 0 )
+                                goto mddone;
+                        }
+                else
+                        {
+                        if( subflg != 0 )
+                                goto mddone;
+                        }
+                }
+        eaddm( rbit, s );
+        }
+mddone:
+#ifdef IBMPC
+if( (exp <= 0) && (rndprc != NBITS) )
+#else
+if( (exp <= 0) && (rndprc != 64) && (rndprc != NBITS) )
+#endif
+        {
+        eshup1(s);
+        }
+if( s[2] != 0 )
+        { /* overflow on roundoff */
+        eshdn1(s);
+        exp += 1;
+        }
+mdfin:
+s[NI-1] = 0;
+if( exp >= 32767L )
+        {
+#ifndef INFINITY
+overf:
+#endif
+#ifdef INFINITY
+        s[1] = 32767;
+        for( i=2; i<NI-1; i++ )
+                s[i] = 0;
+#else
+        s[1] = 32766;
+        s[2] = 0;
+        for( i=M+1; i<NI-1; i++ )
+                s[i] = 0xffff;
+        s[NI-1] = 0;
+        if( (rndprc < 64) || (rndprc == 113) )
+                {
+                s[rw] &= ~rmsk;
+                if( rndprc == 24 )
+                        {
+                        s[5] = 0;
+                        s[6] = 0;
+                        }
+                }
+#endif
+        return;
+        }
+if( exp < 0 )
+        s[1] = 0;
+else
+        s[1] = (unsigned short )exp;
+}
+
+
+
+/*
+;       Subtract external format numbers.
+;
+;       unsigned short a[NE], b[NE], c[NE];
+;       esub( a, b, c );         c = b - a
+*/
+
+static int subflg = 0;
+
+void esub( a, b, c )
+unsigned short *a, *b, *c;
+{
+
+#ifdef NANS
+if( eisnan(a) )
+        {
+        emov (a, c);
+        return;
+        }
+if( eisnan(b) )
+        {
+        emov(b,c);
+        return;
+        }
+/* Infinity minus infinity is a NaN.
+ * Test for subtracting infinities of the same sign.
+ */
+if( eisinf(a) && eisinf(b) && ((eisneg (a) ^ eisneg (b)) == 0))
+        {
+        mtherr( "esub", DOMAIN );
+        enan( c, NBITS );
+        return;
+        }
+#endif
+subflg = 1;
+eadd1( a, b, c );
+}
+
+
+/*
+;       Add.
+;
+;       unsigned short a[NE], b[NE], c[NE];
+;       eadd( a, b, c );         c = b + a
+*/
+void eadd( a, b, c )
+unsigned short *a, *b, *c;
+{
+
+#ifdef NANS
+/* NaN plus anything is a NaN. */
+if( eisnan(a) )
+        {
+        emov(a,c);
+        return;
+        }
+if( eisnan(b) )
+        {
+        emov(b,c);
+        return;
+        }
+/* Infinity minus infinity is a NaN.
+ * Test for adding infinities of opposite signs.
+ */
+if( eisinf(a) && eisinf(b)
+        && ((eisneg(a) ^ eisneg(b)) != 0) )
+        {
+        mtherr( "eadd", DOMAIN );
+        enan( c, NBITS );
+        return;
+        }
+#endif
+subflg = 0;
+eadd1( a, b, c );
+}
+
+void eadd1( a, b, c )
+unsigned short *a, *b, *c;
+{
+unsigned short ai[NI], bi[NI], ci[NI];
+int i, lost, j, k;
+long lt, lta, ltb;
+
+#ifdef INFINITY
+if( eisinf(a) )
+        {
+        emov(a,c);
+        if( subflg )
+                eneg(c);
+        return;
+        }
+if( eisinf(b) )
+        {
+        emov(b,c);
+        return;
+        }
+#endif
+emovi( a, ai );
+emovi( b, bi );
+if( subflg )
+        ai[0] = ~ai[0];
+
+/* compare exponents */
+lta = ai[E];
+ltb = bi[E];
+lt = lta - ltb;
+if( lt > 0L )
+        {       /* put the larger number in bi */
+        emovz( bi, ci );
+        emovz( ai, bi );
+        emovz( ci, ai );
+        ltb = bi[E];
+        lt = -lt;
+        }
+lost = 0;
+if( lt != 0L )
+        {
+        if( lt < (long )(-NBITS-1) )
+                goto done;      /* answer same as larger addend */
+        k = (int )lt;
+        lost = eshift( ai, k ); /* shift the smaller number down */
+        }
+else
+        {
+/* exponents were the same, so must compare significands */
+        i = ecmpm( ai, bi );
+        if( i == 0 )
+                { /* the numbers are identical in magnitude */
+                /* if different signs, result is zero */
+                if( ai[0] != bi[0] )
+                        {
+                        eclear(c);
+                        return;
+                        }
+                /* if same sign, result is double */
+                /* double denomalized tiny number */
+                if( (bi[E] == 0) && ((bi[3] & 0x8000) == 0) )
+                        {
+                        eshup1( bi );
+                        goto done;
+                        }
+                /* add 1 to exponent unless both are zero! */
+                for( j=1; j<NI-1; j++ )
+                        {
+                        if( bi[j] != 0 )
+                                {
+                                ltb += 1;
+                                if( ltb >= 0x7fff )
+                                        {
+                                        eclear(c);
+                                        einfin(c);
+                                        if( ai[0] != 0 )
+                                                eneg(c);
+                                        return;
+                                        }
+                                break;
+                                }
+                        }
+                bi[E] = (unsigned short )ltb;
+                goto done;
+                }
+        if( i > 0 )
+                {       /* put the larger number in bi */
+                emovz( bi, ci );
+                emovz( ai, bi );
+                emovz( ci, ai );
+                }
+        }
+if( ai[0] == bi[0] )
+        {
+        eaddm( ai, bi );
+        subflg = 0;
+        }
+else
+        {
+        esubm( ai, bi );
+        subflg = 1;
+        }
+emdnorm( bi, lost, subflg, ltb, 64 );
+
+done:
+emovo( bi, c );
+}
+
+
+
+/*
+;       Divide.
+;
+;       unsigned short a[NE], b[NE], c[NE];
+;       ediv( a, b, c );        c = b / a
+*/
+void ediv( a, b, c )
+unsigned short *a, *b, *c;
+{
+unsigned short ai[NI], bi[NI];
+int i, sign;
+long lt, lta, ltb;
+
+/* IEEE says if result is not a NaN, the sign is "-" if and only if
+   operands have opposite signs -- but flush -0 to 0 later if not IEEE.  */
+sign = eisneg(a) ^ eisneg(b);
+
+#ifdef NANS
+/* Return any NaN input. */
+if( eisnan(a) )
+        {
+        emov(a,c);
+        return;
+        }
+if( eisnan(b) )
+        {
+        emov(b,c);
+        return;
+        }
+/* Zero over zero, or infinity over infinity, is a NaN. */
+if( ((ecmp(a,ezero) == 0) && (ecmp(b,ezero) == 0))
+        || (eisinf (a) && eisinf (b)) )
+        {
+        mtherr( "ediv", DOMAIN );
+        enan( c, NBITS );
+        return;
+        }
+#endif
+/* Infinity over anything else is infinity. */
+#ifdef INFINITY
+if( eisinf(b) )
+        {
+        einfin(c);
+        goto divsign;
+        }
+if( eisinf(a) )
+        {
+        eclear(c);
+        goto divsign;
+        }
+#endif
+emovi( a, ai );
+emovi( b, bi );
+lta = ai[E];
+ltb = bi[E];
+if( bi[E] == 0 )
+        { /* See if numerator is zero. */
+        for( i=1; i<NI-1; i++ )
+                {
+                if( bi[i] != 0 )
+                        {
+                        ltb -= enormlz( bi );
+                        goto dnzro1;
+                        }
+                }
+        eclear(c);
+        goto divsign;
+        }
+dnzro1:
+
+if( ai[E] == 0 )
+        {       /* possible divide by zero */
+        for( i=1; i<NI-1; i++ )
+                {
+                if( ai[i] != 0 )
+                        {
+                        lta -= enormlz( ai );
+                        goto dnzro2;
+                        }
+                }
+        einfin(c);
+        mtherr( "ediv", SING );
+        goto divsign;
+        }
+dnzro2:
+
+i = edivm( ai, bi );
+/* calculate exponent */
+lt = ltb - lta + EXONE;
+emdnorm( bi, i, 0, lt, 64 );
+emovo( bi, c );
+
+divsign:
+
+if( sign )
+        *(c+(NE-1)) |= 0x8000;
+else
+        *(c+(NE-1)) &= ~0x8000;
+}
+
+
+
+/*
+;       Multiply.
+;
+;       unsigned short a[NE], b[NE], c[NE];
+;       emul( a, b, c );        c = b * a
+*/
+void emul( a, b, c )
+unsigned short *a, *b, *c;
+{
+unsigned short ai[NI], bi[NI];
+int i, j, sign;
+long lt, lta, ltb;
+
+/* IEEE says if result is not a NaN, the sign is "-" if and only if
+   operands have opposite signs -- but flush -0 to 0 later if not IEEE.  */
+sign = eisneg(a) ^ eisneg(b);
+
+#ifdef NANS
+/* NaN times anything is the same NaN. */
+if( eisnan(a) )
+        {
+        emov(a,c);
+        return;
+        }
+if( eisnan(b) )
+        {
+        emov(b,c);
+        return;
+        }
+/* Zero times infinity is a NaN. */
+if( (eisinf(a) && (ecmp(b,ezero) == 0))
+        || (eisinf(b) && (ecmp(a,ezero) == 0)) )
+        {
+        mtherr( "emul", DOMAIN );
+        enan( c, NBITS );
+        return;
+        }
+#endif
+/* Infinity times anything else is infinity. */
+#ifdef INFINITY
+if( eisinf(a) || eisinf(b) )
+        {
+        einfin(c);
+        goto mulsign;
+        }
+#endif
+emovi( a, ai );
+emovi( b, bi );
+lta = ai[E];
+ltb = bi[E];
+if( ai[E] == 0 )
+        {
+        for( i=1; i<NI-1; i++ )
+                {
+                if( ai[i] != 0 )
+                        {
+                        lta -= enormlz( ai );
+                        goto mnzer1;
+                        }
+                }
+        eclear(c);
+        goto mulsign;
+        }
+mnzer1:
+
+if( bi[E] == 0 )
+        {
+        for( i=1; i<NI-1; i++ )
+                {
+                if( bi[i] != 0 )
+                        {
+                        ltb -= enormlz( bi );
+                        goto mnzer2;
+                        }
+                }
+        eclear(c);
+        goto mulsign;
+        }
+mnzer2:
+
+/* Multiply significands */
+j = emulm( ai, bi );
+/* calculate exponent */
+lt = lta + ltb - (EXONE - 1);
+emdnorm( bi, j, 0, lt, 64 );
+emovo( bi, c );
+/*  IEEE says sign is "-" if and only if operands have opposite signs.  */
+mulsign:
+if( sign )
+        *(c+(NE-1)) |= 0x8000;
+else
+        *(c+(NE-1)) &= ~0x8000;
+}
+
+
+
+
+/*
+; Convert IEEE double precision to e type
+;       double d;
+;       unsigned short x[N+2];
+;       e53toe( &d, x );
+*/
+void e53toe( pe, y )
+unsigned short *pe, *y;
+{
+#ifdef DEC
+
+dectoe( pe, y ); /* see etodec.c */
+
+#else
+
+register unsigned short r;
+register unsigned short *p, *e;
+unsigned short yy[NI];
+int denorm, k;
+
+e = pe;
+denorm = 0;     /* flag if denormalized number */
+ecleaz(yy);
+#ifdef IBMPC
+e += 3;
+#endif
+r = *e;
+yy[0] = 0;
+if( r & 0x8000 )
+        yy[0] = 0xffff;
+yy[M] = (r & 0x0f) | 0x10;
+r &= ~0x800f;   /* strip sign and 4 significand bits */
+#ifdef INFINITY
+if( r == 0x7ff0 )
+        {
+#ifdef NANS
+#ifdef IBMPC
+        if( ((pe[3] & 0xf) != 0) || (pe[2] != 0)
+                || (pe[1] != 0) || (pe[0] != 0) )
+                {
+                enan( y, NBITS );
+                return;
+                }
+#else
+        if( ((pe[0] & 0xf) != 0) || (pe[1] != 0)
+                 || (pe[2] != 0) || (pe[3] != 0) )
+                {
+                enan( y, NBITS );
+                return;
+                }
+#endif
+#endif  /* NANS */
+        eclear( y );
+        einfin( y );
+        if( yy[0] )
+                eneg(y);
+        return;
+        }
+#endif
+r >>= 4;
+/* If zero exponent, then the significand is denormalized.
+ * So, take back the understood high significand bit. */ 
+if( r == 0 )
+        {
+        denorm = 1;
+        yy[M] &= ~0x10;
+        }
+r += EXONE - 01777;
+yy[E] = r;
+p = &yy[M+1];
+#ifdef IBMPC
+*p++ = *(--e);
+*p++ = *(--e);
+*p++ = *(--e);
+#endif
+#ifdef MIEEE
+++e;
+*p++ = *e++;
+*p++ = *e++;
+*p++ = *e++;
+#endif
+(void )eshift( yy, -5 );
+if( denorm )
+        { /* if zero exponent, then normalize the significand */
+        if( (k = enormlz(yy)) > NBITS )
+                ecleazs(yy);
+        else
+                yy[E] -= (unsigned short )(k-1);
+        }
+emovo( yy, y );
+#endif /* not DEC */
+}
+
+void e64toe( pe, y )
+unsigned short *pe, *y;
+{
+unsigned short yy[NI];
+unsigned short *p, *q, *e;
+int i;
+
+e = pe;
+p = yy;
+for( i=0; i<NE-5; i++ )
+        *p++ = 0;
+#ifdef IBMPC
+for( i=0; i<5; i++ )
+        *p++ = *e++;
+#endif
+#ifdef DEC
+for( i=0; i<5; i++ )
+        *p++ = *e++;
+#endif
+#ifdef MIEEE
+p = &yy[0] + (NE-1);
+*p-- = *e++;
+++e;
+for( i=0; i<4; i++ )
+        *p-- = *e++;
+#endif
+
+#ifdef IBMPC
+/* For Intel long double, shift denormal significand up 1
+   -- but only if the top significand bit is zero.  */
+if((yy[NE-1] & 0x7fff) == 0 && (yy[NE-2] & 0x8000) == 0)
+  {
+    unsigned short temp[NI+1];
+    emovi(yy, temp);
+    eshup1(temp);
+    emovo(temp,y);
+    return;
+  }
+#endif
+#ifdef INFINITY
+/* Point to the exponent field.  */
+p = &yy[NE-1];
+if ((*p & 0x7fff) == 0x7fff)
+        {
+#ifdef NANS
+#ifdef IBMPC
+        for( i=0; i<4; i++ )
+                {
+                if((i != 3 && pe[i] != 0)
+                   /* Check for Intel long double infinity pattern.  */
+                   || (i == 3 && pe[i] != 0x8000))
+                        {
+                        enan( y, NBITS );
+                        return;
+                        }
+                }
+#else
+        /* In Motorola extended precision format, the most significant
+           bit of an infinity mantissa could be either 1 or 0.  It is
+           the lower order bits that tell whether the value is a NaN.  */
+        if ((pe[2] & 0x7fff) != 0)
+                goto bigend_nan;
+
+        for( i=3; i<=5; i++ )
+                {
+                if( pe[i] != 0 )
+                        {
+bigend_nan:
+                        enan( y, NBITS );
+                        return;
+                        }
+                }
+#endif
+#endif /* NANS */
+        eclear( y );
+        einfin( y );
+        if( *p & 0x8000 )
+                eneg(y);
+        return;
+        }
+#endif
+p = yy;
+q = y;
+for( i=0; i<NE; i++ )
+        *q++ = *p++;
+}
+
+void e113toe(pe,y)
+unsigned short *pe, *y;
+{
+register unsigned short r;
+unsigned short *e, *p;
+unsigned short yy[NI];
+int denorm, i;
+
+e = pe;
+denorm = 0;
+ecleaz(yy);
+#ifdef IBMPC
+e += 7;
+#endif
+r = *e;
+yy[0] = 0;
+if( r & 0x8000 )
+        yy[0] = 0xffff;
+r &= 0x7fff;
+#ifdef INFINITY
+if( r == 0x7fff )
+        {
+#ifdef NANS
+#ifdef IBMPC
+        for( i=0; i<7; i++ )
+                {
+                if( pe[i] != 0 )
+                        {
+                        enan( y, NBITS );
+                        return;
+                        }
+                }
+#else
+        for( i=1; i<8; i++ )
+                {
+                if( pe[i] != 0 )
+                        {
+                        enan( y, NBITS );
+                        return;
+                        }
+                }
+#endif
+#endif /* NANS */
+        eclear( y );
+        einfin( y );
+        if( *e & 0x8000 )
+                eneg(y);
+        return;
+        }
+#endif  /* INFINITY */
+yy[E] = r;
+p = &yy[M + 1];
+#ifdef IBMPC
+for( i=0; i<7; i++ )
+        *p++ = *(--e);
+#endif
+#ifdef MIEEE
+++e;
+for( i=0; i<7; i++ )
+        *p++ = *e++;
+#endif
+/* If denormal, remove the implied bit; else shift down 1. */
+if( r == 0 )
+        {
+        yy[M] = 0;
+        }
+else
+        {
+        yy[M] = 1;
+        eshift( yy, -1 );
+        }
+emovo(yy,y);
+}
+
+
+/*
+; Convert IEEE single precision to e type
+;       float d;
+;       unsigned short x[N+2];
+;       dtox( &d, x );
+*/
+void e24toe( pe, y )
+unsigned short *pe, *y;
+{
+register unsigned short r;
+register unsigned short *p, *e;
+unsigned short yy[NI];
+int denorm, k;
+
+e = pe;
+denorm = 0;     /* flag if denormalized number */
+ecleaz(yy);
+#ifdef IBMPC
+e += 1;
+#endif
+#ifdef DEC
+e += 1;
+#endif
+r = *e;
+yy[0] = 0;
+if( r & 0x8000 )
+        yy[0] = 0xffff;
+yy[M] = (r & 0x7f) | 0200;
+r &= ~0x807f;   /* strip sign and 7 significand bits */
+#ifdef INFINITY
+if( r == 0x7f80 )
+        {
+#ifdef NANS
+#ifdef MIEEE
+        if( ((pe[0] & 0x7f) != 0) || (pe[1] != 0) )
+                {
+                enan( y, NBITS );
+                return;
+                }
+#else
+        if( ((pe[1] & 0x7f) != 0) || (pe[0] != 0) )
+                {
+                enan( y, NBITS );
+                return;
+                }
+#endif
+#endif  /* NANS */
+        eclear( y );
+        einfin( y );
+        if( yy[0] )
+                eneg(y);
+        return;
+        }
+#endif
+r >>= 7;
+/* If zero exponent, then the significand is denormalized.
+ * So, take back the understood high significand bit. */ 
+if( r == 0 )
+        {
+        denorm = 1;
+        yy[M] &= ~0200;
+        }
+r += EXONE - 0177;
+yy[E] = r;
+p = &yy[M+1];
+#ifdef IBMPC
+*p++ = *(--e);
+#endif
+#ifdef DEC
+*p++ = *(--e);
+#endif
+#ifdef MIEEE
+++e;
+*p++ = *e++;
+#endif
+(void )eshift( yy, -8 );
+if( denorm )
+        { /* if zero exponent, then normalize the significand */
+        if( (k = enormlz(yy)) > NBITS )
+                ecleazs(yy);
+        else
+                yy[E] -= (unsigned short )(k-1);
+        }
+emovo( yy, y );
+}
+
+void etoe113(x,e)
+unsigned short *x, *e;
+{
+unsigned short xi[NI];
+long exp;
+int rndsav;
+
+#ifdef NANS
+if( eisnan(x) )
+        {
+        enan( e, 113 );
+        return;
+        }
+#endif
+emovi( x, xi );
+exp = (long )xi[E];
+#ifdef INFINITY
+if( eisinf(x) )
+        goto nonorm;
+#endif
+/* round off to nearest or even */
+rndsav = rndprc;
+rndprc = 113;
+emdnorm( xi, 0, 0, exp, 64 );
+rndprc = rndsav;
+nonorm:
+toe113 (xi, e);
+}
+
+/* move out internal format to ieee long double */
+static void toe113(a,b)
+unsigned short *a, *b;
+{
+register unsigned short *p, *q;
+unsigned short i;
+
+#ifdef NANS
+if( eiisnan(a) )
+        {
+        enan( b, 113 );
+        return;
+        }
+#endif
+p = a;
+#ifdef MIEEE
+q = b;
+#else
+q = b + 7;                      /* point to output exponent */
+#endif
+
+/* If not denormal, delete the implied bit. */
+if( a[E] != 0 )
+        {
+        eshup1 (a);
+        }
+/* combine sign and exponent */
+i = *p++;
+#ifdef MIEEE
+if( i )
+        *q++ = *p++ | 0x8000;
+else
+        *q++ = *p++;
+#else
+if( i )
+        *q-- = *p++ | 0x8000;
+else
+        *q-- = *p++;
+#endif
+/* skip over guard word */
+++p;
+/* move the significand */
+#ifdef MIEEE
+for (i = 0; i < 7; i++)
+        *q++ = *p++;
+#else
+for (i = 0; i < 7; i++)
+        *q-- = *p++;
+#endif
+}
+
+
+void etoe64( x, e )
+unsigned short *x, *e;
+{
+unsigned short xi[NI];
+long exp;
+int rndsav;
+
+#ifdef NANS
+if( eisnan(x) )
+        {
+        enan( e, 64 );
+        return;
+        }
+#endif
+emovi( x, xi );
+exp = (long )xi[E]; /* adjust exponent for offset */
+#ifdef INFINITY
+if( eisinf(x) )
+        goto nonorm;
+#endif
+/* round off to nearest or even */
+rndsav = rndprc;
+rndprc = 64;
+emdnorm( xi, 0, 0, exp, 64 );
+rndprc = rndsav;
+nonorm:
+toe64( xi, e );
+}
+
+/* move out internal format to ieee long double */
+static void toe64( a, b )
+unsigned short *a, *b;
+{
+register unsigned short *p, *q;
+unsigned short i;
+
+#ifdef NANS
+if( eiisnan(a) )
+        {
+        enan( b, 64 );
+        return;
+        }
+#endif
+#ifdef IBMPC
+/* Shift Intel denormal significand down 1.  */
+if( a[E] == 0 )
+  eshdn1(a);
+#endif
+p = a;
+#ifdef MIEEE
+q = b;
+#else
+q = b + 4; /* point to output exponent */
+#if 1
+/* NOTE: if data type is 96 bits wide, clear the last word here. */
+*(q+1)= 0;
+#endif
+#endif
+
+/* combine sign and exponent */
+i = *p++;
+#ifdef MIEEE
+if( i )
+        *q++ = *p++ | 0x8000;
+else
+        *q++ = *p++;
+*q++ = 0;
+#else
+if( i )
+        *q-- = *p++ | 0x8000;
+else
+        *q-- = *p++;
+#endif
+/* skip over guard word */
+++p;
+/* move the significand */
+#ifdef MIEEE
+for( i=0; i<4; i++ )
+        *q++ = *p++;
+#else
+#ifdef INFINITY
+if (eiisinf (a))
+        {
+        /* Intel long double infinity.  */
+        *q-- = 0x8000;
+        *q-- = 0;
+        *q-- = 0;
+        *q = 0;
+        return;
+        }
+#endif
+for( i=0; i<4; i++ )
+        *q-- = *p++;
+#endif
+}
+
+
+/*
+; e type to IEEE double precision
+;       double d;
+;       unsigned short x[NE];
+;       etoe53( x, &d );
+*/
+
+#ifdef DEC
+
+void etoe53( x, e )
+unsigned short *x, *e;
+{
+etodec( x, e ); /* see etodec.c */
+}
+
+static void toe53( x, y )
+unsigned short *x, *y;
+{
+todec( x, y );
+}
+
+#else
+
+void etoe53( x, e )
+unsigned short *x, *e;
+{
+unsigned short xi[NI];
+long exp;
+int rndsav;
+
+#ifdef NANS
+if( eisnan(x) )
+        {
+        enan( e, 53 );
+        return;
+        }
+#endif
+emovi( x, xi );
+exp = (long )xi[E] - (EXONE - 0x3ff); /* adjust exponent for offsets */
+#ifdef INFINITY
+if( eisinf(x) )
+        goto nonorm;
+#endif
+/* round off to nearest or even */
+rndsav = rndprc;
+rndprc = 53;
+emdnorm( xi, 0, 0, exp, 64 );
+rndprc = rndsav;
+nonorm:
+toe53( xi, e );
+}
+
+
+static void toe53( x, y )
+unsigned short *x, *y;
+{
+unsigned short i;
+unsigned short *p;
+
+
+#ifdef NANS
+if( eiisnan(x) )
+        {
+        enan( y, 53 );
+        return;
+        }
+#endif
+p = &x[0];
+#ifdef IBMPC
+y += 3;
+#endif
+*y = 0; /* output high order */
+if( *p++ )
+        *y = 0x8000;    /* output sign bit */
+
+i = *p++;
+if( i >= (unsigned int )2047 )
+        {       /* Saturate at largest number less than infinity. */
+#ifdef INFINITY
+        *y |= 0x7ff0;
+#ifdef IBMPC
+        *(--y) = 0;
+        *(--y) = 0;
+        *(--y) = 0;
+#endif
+#ifdef MIEEE
+        ++y;
+        *y++ = 0;
+        *y++ = 0;
+        *y++ = 0;
+#endif
+#else
+        *y |= (unsigned short )0x7fef;
+#ifdef IBMPC
+        *(--y) = 0xffff;
+        *(--y) = 0xffff;
+        *(--y) = 0xffff;
+#endif
+#ifdef MIEEE
+        ++y;
+        *y++ = 0xffff;
+        *y++ = 0xffff;
+        *y++ = 0xffff;
+#endif
+#endif
+        return;
+        }
+if( i == 0 )
+        {
+        (void )eshift( x, 4 );
+        }
+else
+        {
+        i <<= 4;
+        (void )eshift( x, 5 );
+        }
+i |= *p++ & (unsigned short )0x0f;      /* *p = xi[M] */
+*y |= (unsigned short )i; /* high order output already has sign bit set */
+#ifdef IBMPC
+*(--y) = *p++;
+*(--y) = *p++;
+*(--y) = *p;
+#endif
+#ifdef MIEEE
+++y;
+*y++ = *p++;
+*y++ = *p++;
+*y++ = *p++;
+#endif
+}
+
+#endif /* not DEC */
+
+
+
+/*
+; e type to IEEE single precision
+;       float d;
+;       unsigned short x[N+2];
+;       xtod( x, &d );
+*/
+void etoe24( x, e )
+unsigned short *x, *e;
+{
+long exp;
+unsigned short xi[NI];
+int rndsav;
+
+#ifdef NANS
+if( eisnan(x) )
+        {
+        enan( e, 24 );
+        return;
+        }
+#endif
+emovi( x, xi );
+exp = (long )xi[E] - (EXONE - 0177); /* adjust exponent for offsets */
+#ifdef INFINITY
+if( eisinf(x) )
+        goto nonorm;
+#endif
+/* round off to nearest or even */
+rndsav = rndprc;
+rndprc = 24;
+emdnorm( xi, 0, 0, exp, 64 );
+rndprc = rndsav;
+nonorm:
+toe24( xi, e );
+}
+
+static void toe24( x, y )
+unsigned short *x, *y;
+{
+unsigned short i;
+unsigned short *p;
+
+#ifdef NANS
+if( eiisnan(x) )
+        {
+        enan( y, 24 );
+        return;
+        }
+#endif
+p = &x[0];
+#ifdef IBMPC
+y += 1;
+#endif
+#ifdef DEC
+y += 1;
+#endif
+*y = 0; /* output high order */
+if( *p++ )
+        *y = 0x8000;    /* output sign bit */
+
+i = *p++;
+if( i >= 255 )
+        {       /* Saturate at largest number less than infinity. */
+#ifdef INFINITY
+        *y |= (unsigned short )0x7f80;
+#ifdef IBMPC
+        *(--y) = 0;
+#endif
+#ifdef DEC
+        *(--y) = 0;
+#endif
+#ifdef MIEEE
+        ++y;
+        *y = 0;
+#endif
+#else
+        *y |= (unsigned short )0x7f7f;
+#ifdef IBMPC
+        *(--y) = 0xffff;
+#endif
+#ifdef DEC
+        *(--y) = 0xffff;
+#endif
+#ifdef MIEEE
+        ++y;
+        *y = 0xffff;
+#endif
+#endif
+        return;
+        }
+if( i == 0 )
+        {
+        (void )eshift( x, 7 );
+        }
+else
+        {
+        i <<= 7;
+        (void )eshift( x, 8 );
+        }
+i |= *p++ & (unsigned short )0x7f;      /* *p = xi[M] */
+*y |= i;        /* high order output already has sign bit set */
+#ifdef IBMPC
+*(--y) = *p;
+#endif
+#ifdef DEC
+*(--y) = *p;
+#endif
+#ifdef MIEEE
+++y;
+*y = *p;
+#endif
+}
+
+
+/* Compare two e type numbers.
+ *
+ * unsigned short a[NE], b[NE];
+ * ecmp( a, b );
+ *
+ *  returns +1 if a > b
+ *           0 if a == b
+ *          -1 if a < b
+ *          -2 if either a or b is a NaN.
+ */
+int ecmp( a, b )
+unsigned short *a, *b;
+{
+unsigned short ai[NI], bi[NI];
+register unsigned short *p, *q;
+register int i;
+int msign;
+
+#ifdef NANS
+if (eisnan (a)  || eisnan (b))
+        return( -2 );
+#endif
+emovi( a, ai );
+p = ai;
+emovi( b, bi );
+q = bi;
+
+if( *p != *q )
+        { /* the signs are different */
+/* -0 equals + 0 */
+        for( i=1; i<NI-1; i++ )
+                {
+                if( ai[i] != 0 )
+                        goto nzro;
+                if( bi[i] != 0 )
+                        goto nzro;
+                }
+        return(0);
+nzro:
+        if( *p == 0 )
+                return( 1 );
+        else
+                return( -1 );
+        }
+/* both are the same sign */
+if( *p == 0 )
+        msign = 1;
+else
+        msign = -1;
+i = NI-1;
+do
+        {
+        if( *p++ != *q++ )
+                {
+                goto diff;
+                }
+        }
+while( --i > 0 );
+
+return(0);      /* equality */
+
+
+
+diff:
+
+if( *(--p) > *(--q) )
+        return( msign );                /* p is bigger */
+else
+        return( -msign );       /* p is littler */
+}
+
+
+
+
+/* Find nearest integer to x = floor( x + 0.5 )
+ *
+ * unsigned short x[NE], y[NE]
+ * eround( x, y );
+ */
+void eround( x, y )
+unsigned short *x, *y;
+{
+
+eadd( ehalf, x, y );
+efloor( y, y );
+}
+
+
+
+
+/*
+; convert long (32-bit) integer to e type
+;
+;       long l;
+;       unsigned short x[NE];
+;       ltoe( &l, x );
+; note &l is the memory address of l
+*/
+void ltoe( lp, y )
+long *lp;       /* lp is the memory address of a long integer */
+unsigned short *y;      /* y is the address of a short */
+{
+unsigned short yi[NI];
+unsigned long ll;
+int k;
+
+ecleaz( yi );
+if( *lp < 0 )
+        {
+        ll =  (unsigned long )( -(*lp) ); /* make it positive */
+        yi[0] = 0xffff; /* put correct sign in the e type number */
+        }
+else
+        {
+        ll = (unsigned long )( *lp );
+        }
+/* move the long integer to yi significand area */
+if( sizeof(long) == 8 )
+        {
+        yi[M] = (unsigned short) (ll >> (LONGBITS - 16));
+        yi[M + 1] = (unsigned short) (ll >> (LONGBITS - 32));
+        yi[M + 2] = (unsigned short) (ll >> 16);
+        yi[M + 3] = (unsigned short) ll;
+        yi[E] = EXONE + 47; /* exponent if normalize shift count were 0 */
+        }
+else
+        {
+        yi[M] = (unsigned short )(ll >> 16); 
+        yi[M+1] = (unsigned short )ll;
+        yi[E] = EXONE + 15; /* exponent if normalize shift count were 0 */
+        }
+if( (k = enormlz( yi )) > NBITS ) /* normalize the significand */
+        ecleaz( yi );   /* it was zero */
+else
+        yi[E] -= (unsigned short )k; /* subtract shift count from exponent */
+emovo( yi, y ); /* output the answer */
+}
+
+/*
+; convert unsigned long (32-bit) integer to e type
+;
+;       unsigned long l;
+;       unsigned short x[NE];
+;       ltox( &l, x );
+; note &l is the memory address of l
+*/
+void ultoe( lp, y )
+unsigned long *lp; /* lp is the memory address of a long integer */
+unsigned short *y;      /* y is the address of a short */
+{
+unsigned short yi[NI];
+unsigned long ll;
+int k;
+
+ecleaz( yi );
+ll = *lp;
+
+/* move the long integer to ayi significand area */
+if( sizeof(long) == 8 )
+        {
+        yi[M] = (unsigned short) (ll >> (LONGBITS - 16));
+        yi[M + 1] = (unsigned short) (ll >> (LONGBITS - 32));
+        yi[M + 2] = (unsigned short) (ll >> 16);
+        yi[M + 3] = (unsigned short) ll;
+        yi[E] = EXONE + 47; /* exponent if normalize shift count were 0 */
+        }
+else
+        {
+        yi[M] = (unsigned short )(ll >> 16); 
+        yi[M+1] = (unsigned short )ll;
+        yi[E] = EXONE + 15; /* exponent if normalize shift count were 0 */
+        }
+if( (k = enormlz( yi )) > NBITS ) /* normalize the significand */
+        ecleaz( yi );   /* it was zero */
+else
+        yi[E] -= (unsigned short )k; /* subtract shift count from exponent */
+emovo( yi, y ); /* output the answer */
+}
+
+
+/*
+;       Find long integer and fractional parts
+
+;       long i;
+;       unsigned short x[NE], frac[NE];
+;       xifrac( x, &i, frac );
+ 
+  The integer output has the sign of the input.  The fraction is
+  the positive fractional part of abs(x).
+*/
+void eifrac( x, i, frac )
+unsigned short *x;
+long *i;
+unsigned short *frac;
+{
+unsigned short xi[NI];
+int j, k;
+unsigned long ll;
+
+emovi( x, xi );
+k = (int )xi[E] - (EXONE - 1);
+if( k <= 0 )
+        {
+/* if exponent <= 0, integer = 0 and real output is fraction */
+        *i = 0L;
+        emovo( xi, frac );
+        return;
+        }
+if( k > (8 * sizeof(long) - 1) )
+        {
+/*
+;       long integer overflow: output large integer
+;       and correct fraction
+*/
+        j = 8 * sizeof(long) - 1;
+        if( xi[0] )
+                *i = (long) ((unsigned long) 1) << j;
+        else
+                *i = (long) (((unsigned long) (~(0L))) >> 1);
+        (void )eshift( xi, k );
+        }
+if( k > 16 )
+        {
+/*
+  Shift more than 16 bits: shift up k-16 mod 16
+  then shift by 16's.
+*/
+        j = k - ((k >> 4) << 4);
+        eshift (xi, j);
+        ll = xi[M];
+        k -= j;
+        do
+                {
+                eshup6 (xi);
+                ll = (ll << 16) | xi[M];
+                }
+        while ((k -= 16) > 0);
+        *i = ll;
+        if (xi[0])
+                *i = -(*i);
+        }
+else
+        {
+/* shift not more than 16 bits */
+        eshift( xi, k );
+        *i = (long )xi[M] & 0xffff;
+        if( xi[0] )
+                *i = -(*i);
+        }
+xi[0] = 0;
+xi[E] = EXONE - 1;
+xi[M] = 0;
+if( (k = enormlz( xi )) > NBITS )
+        ecleaz( xi );
+else
+        xi[E] -= (unsigned short )k;
+
+emovo( xi, frac );
+}
+
+
+/*
+;       Find unsigned long integer and fractional parts
+
+;       unsigned long i;
+;       unsigned short x[NE], frac[NE];
+;       xifrac( x, &i, frac );
+
+  A negative e type input yields integer output = 0
+  but correct fraction.
+*/
+void euifrac( x, i, frac )
+unsigned short *x;
+unsigned long *i;
+unsigned short *frac;
+{
+unsigned short xi[NI];
+int j, k;
+unsigned long ll;
+
+emovi( x, xi );
+k = (int )xi[E] - (EXONE - 1);
+if( k <= 0 )
+        {
+/* if exponent <= 0, integer = 0 and argument is fraction */
+        *i = 0L;
+        emovo( xi, frac );
+        return;
+        }
+if( k > (8 * sizeof(long)) )
+        {
+/*
+;       long integer overflow: output large integer
+;       and correct fraction
+*/
+        *i = ~(0L);
+        (void )eshift( xi, k );
+        }
+else if( k > 16 )
+        {
+/*
+  Shift more than 16 bits: shift up k-16 mod 16
+  then shift up by 16's.
+*/
+        j = k - ((k >> 4) << 4);
+        eshift (xi, j);
+        ll = xi[M];
+        k -= j;
+        do
+                {
+                eshup6 (xi);
+                ll = (ll << 16) | xi[M];
+                }
+        while ((k -= 16) > 0);
+        *i = ll;
+        }
+else
+        {
+/* shift not more than 16 bits */
+        eshift( xi, k );
+        *i = (long )xi[M] & 0xffff;
+        }
+
+if( xi[0] )  /* A negative value yields unsigned integer 0. */
+        *i = 0L;
+
+xi[0] = 0;
+xi[E] = EXONE - 1;
+xi[M] = 0;
+if( (k = enormlz( xi )) > NBITS )
+        ecleaz( xi );
+else
+        xi[E] -= (unsigned short )k;
+
+emovo( xi, frac );
+}
+
+
+
+/*
+;       Shift significand
+;
+;       Shifts significand area up or down by the number of bits
+;       given by the variable sc.
+*/
+int eshift( x, sc )
+unsigned short *x;
+int sc;
+{
+unsigned short lost;
+unsigned short *p;
+
+if( sc == 0 )
+        return( 0 );
+
+lost = 0;
+p = x + NI-1;
+
+if( sc < 0 )
+        {
+        sc = -sc;
+        while( sc >= 16 )
+                {
+                lost |= *p;     /* remember lost bits */
+                eshdn6(x);
+                sc -= 16;
+                }
+
+        while( sc >= 8 )
+                {
+                lost |= *p & 0xff;
+                eshdn8(x);
+                sc -= 8;
+                }
+
+        while( sc > 0 )
+                {
+                lost |= *p & 1;
+                eshdn1(x);
+                sc -= 1;
+                }
+        }
+else
+        {
+        while( sc >= 16 )
+                {
+                eshup6(x);
+                sc -= 16;
+                }
+
+        while( sc >= 8 )
+                {
+                eshup8(x);
+                sc -= 8;
+                }
+
+        while( sc > 0 )
+                {
+                eshup1(x);
+                sc -= 1;
+                }
+        }
+if( lost )
+        lost = 1;
+return( (int )lost );
+}
+
+
+
+/*
+;       normalize
+;
+; Shift normalizes the significand area pointed to by argument
+; shift count (up = positive) is returned.
+*/
+int enormlz(x)
+unsigned short x[];
+{
+register unsigned short *p;
+int sc;
+
+sc = 0;
+p = &x[M];
+if( *p != 0 )
+        goto normdn;
+++p;
+if( *p & 0x8000 )
+        return( 0 );    /* already normalized */
+while( *p == 0 )
+        {
+        eshup6(x);
+        sc += 16;
+/* With guard word, there are NBITS+16 bits available.
+ * return true if all are zero.
+ */
+        if( sc > NBITS )
+                return( sc );
+        }
+/* see if high byte is zero */
+while( (*p & 0xff00) == 0 )
+        {
+        eshup8(x);
+        sc += 8;
+        }
+/* now shift 1 bit at a time */
+while( (*p  & 0x8000) == 0)
+        {
+        eshup1(x);
+        sc += 1;
+        if( sc > (NBITS+16) )
+                {
+                mtherr( "enormlz", UNDERFLOW );
+                return( sc );
+                }
+        }
+return( sc );
+
+/* Normalize by shifting down out of the high guard word
+   of the significand */
+normdn:
+
+if( *p & 0xff00 )
+        {
+        eshdn8(x);
+        sc -= 8;
+        }
+while( *p != 0 )
+        {
+        eshdn1(x);
+        sc -= 1;
+
+        if( sc < -NBITS )
+                {
+                mtherr( "enormlz", OVERFLOW );
+                return( sc );
+                }
+        }
+return( sc );
+}
+
+
+
+
+/* Convert e type number to decimal format ASCII string.
+ * The constants are for 64 bit precision.
+ */
+
+#define NTEN 12
+#define MAXP 4096
+
+#if NE == 10
+static unsigned short etens[NTEN + 1][NE] =
+{
+  {0x6576, 0x4a92, 0x804a, 0x153f,
+   0xc94c, 0x979a, 0x8a20, 0x5202, 0xc460, 0x7525,},    /* 10**4096 */
+  {0x6a32, 0xce52, 0x329a, 0x28ce,
+   0xa74d, 0x5de4, 0xc53d, 0x3b5d, 0x9e8b, 0x5a92,},    /* 10**2048 */
+  {0x526c, 0x50ce, 0xf18b, 0x3d28,
+   0x650d, 0x0c17, 0x8175, 0x7586, 0xc976, 0x4d48,},
+  {0x9c66, 0x58f8, 0xbc50, 0x5c54,
+   0xcc65, 0x91c6, 0xa60e, 0xa0ae, 0xe319, 0x46a3,},
+  {0x851e, 0xeab7, 0x98fe, 0x901b,
+   0xddbb, 0xde8d, 0x9df9, 0xebfb, 0xaa7e, 0x4351,},
+  {0x0235, 0x0137, 0x36b1, 0x336c,
+   0xc66f, 0x8cdf, 0x80e9, 0x47c9, 0x93ba, 0x41a8,},
+  {0x50f8, 0x25fb, 0xc76b, 0x6b71,
+   0x3cbf, 0xa6d5, 0xffcf, 0x1f49, 0xc278, 0x40d3,},
+  {0x0000, 0x0000, 0x0000, 0x0000,
+   0xf020, 0xb59d, 0x2b70, 0xada8, 0x9dc5, 0x4069,},
+  {0x0000, 0x0000, 0x0000, 0x0000,
+   0x0000, 0x0000, 0x0400, 0xc9bf, 0x8e1b, 0x4034,},
+  {0x0000, 0x0000, 0x0000, 0x0000,
+   0x0000, 0x0000, 0x0000, 0x2000, 0xbebc, 0x4019,},
+  {0x0000, 0x0000, 0x0000, 0x0000,
+   0x0000, 0x0000, 0x0000, 0x0000, 0x9c40, 0x400c,},
+  {0x0000, 0x0000, 0x0000, 0x0000,
+   0x0000, 0x0000, 0x0000, 0x0000, 0xc800, 0x4005,},
+  {0x0000, 0x0000, 0x0000, 0x0000,
+   0x0000, 0x0000, 0x0000, 0x0000, 0xa000, 0x4002,},    /* 10**1 */
+};
+
+static unsigned short emtens[NTEN + 1][NE] =
+{
+  {0x2030, 0xcffc, 0xa1c3, 0x8123,
+   0x2de3, 0x9fde, 0xd2ce, 0x04c8, 0xa6dd, 0x0ad8,},    /* 10**-4096 */
+  {0x8264, 0xd2cb, 0xf2ea, 0x12d4,
+   0x4925, 0x2de4, 0x3436, 0x534f, 0xceae, 0x256b,},    /* 10**-2048 */
+  {0xf53f, 0xf698, 0x6bd3, 0x0158,
+   0x87a6, 0xc0bd, 0xda57, 0x82a5, 0xa2a6, 0x32b5,},
+  {0xe731, 0x04d4, 0xe3f2, 0xd332,
+   0x7132, 0xd21c, 0xdb23, 0xee32, 0x9049, 0x395a,},
+  {0xa23e, 0x5308, 0xfefb, 0x1155,
+   0xfa91, 0x1939, 0x637a, 0x4325, 0xc031, 0x3cac,},
+  {0xe26d, 0xdbde, 0xd05d, 0xb3f6,
+   0xac7c, 0xe4a0, 0x64bc, 0x467c, 0xddd0, 0x3e55,},
+  {0x2a20, 0x6224, 0x47b3, 0x98d7,
+   0x3f23, 0xe9a5, 0xa539, 0xea27, 0xa87f, 0x3f2a,},
+  {0x0b5b, 0x4af2, 0xa581, 0x18ed,
+   0x67de, 0x94ba, 0x4539, 0x1ead, 0xcfb1, 0x3f94,},
+  {0xbf71, 0xa9b3, 0x7989, 0xbe68,
+   0x4c2e, 0xe15b, 0xc44d, 0x94be, 0xe695, 0x3fc9,},
+  {0x3d4d, 0x7c3d, 0x36ba, 0x0d2b,
+   0xfdc2, 0xcefc, 0x8461, 0x7711, 0xabcc, 0x3fe4,},
+  {0xc155, 0xa4a8, 0x404e, 0x6113,
+   0xd3c3, 0x652b, 0xe219, 0x1758, 0xd1b7, 0x3ff1,},
+  {0xd70a, 0x70a3, 0x0a3d, 0xa3d7,
+   0x3d70, 0xd70a, 0x70a3, 0x0a3d, 0xa3d7, 0x3ff8,},
+  {0xcccd, 0xcccc, 0xcccc, 0xcccc,
+   0xcccc, 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0x3ffb,},    /* 10**-1 */
+};
+#else
+static unsigned short etens[NTEN+1][NE] = {
+{0xc94c,0x979a,0x8a20,0x5202,0xc460,0x7525,},/* 10**4096 */
+{0xa74d,0x5de4,0xc53d,0x3b5d,0x9e8b,0x5a92,},/* 10**2048 */
+{0x650d,0x0c17,0x8175,0x7586,0xc976,0x4d48,},
+{0xcc65,0x91c6,0xa60e,0xa0ae,0xe319,0x46a3,},
+{0xddbc,0xde8d,0x9df9,0xebfb,0xaa7e,0x4351,},
+{0xc66f,0x8cdf,0x80e9,0x47c9,0x93ba,0x41a8,},
+{0x3cbf,0xa6d5,0xffcf,0x1f49,0xc278,0x40d3,},
+{0xf020,0xb59d,0x2b70,0xada8,0x9dc5,0x4069,},
+{0x0000,0x0000,0x0400,0xc9bf,0x8e1b,0x4034,},
+{0x0000,0x0000,0x0000,0x2000,0xbebc,0x4019,},
+{0x0000,0x0000,0x0000,0x0000,0x9c40,0x400c,},
+{0x0000,0x0000,0x0000,0x0000,0xc800,0x4005,},
+{0x0000,0x0000,0x0000,0x0000,0xa000,0x4002,}, /* 10**1 */
+};
+
+static unsigned short emtens[NTEN+1][NE] = {
+{0x2de4,0x9fde,0xd2ce,0x04c8,0xa6dd,0x0ad8,}, /* 10**-4096 */
+{0x4925,0x2de4,0x3436,0x534f,0xceae,0x256b,}, /* 10**-2048 */
+{0x87a6,0xc0bd,0xda57,0x82a5,0xa2a6,0x32b5,},
+{0x7133,0xd21c,0xdb23,0xee32,0x9049,0x395a,},
+{0xfa91,0x1939,0x637a,0x4325,0xc031,0x3cac,},
+{0xac7d,0xe4a0,0x64bc,0x467c,0xddd0,0x3e55,},
+{0x3f24,0xe9a5,0xa539,0xea27,0xa87f,0x3f2a,},
+{0x67de,0x94ba,0x4539,0x1ead,0xcfb1,0x3f94,},
+{0x4c2f,0xe15b,0xc44d,0x94be,0xe695,0x3fc9,},
+{0xfdc2,0xcefc,0x8461,0x7711,0xabcc,0x3fe4,},
+{0xd3c3,0x652b,0xe219,0x1758,0xd1b7,0x3ff1,},
+{0x3d71,0xd70a,0x70a3,0x0a3d,0xa3d7,0x3ff8,},
+{0xcccd,0xcccc,0xcccc,0xcccc,0xcccc,0x3ffb,}, /* 10**-1 */
+};
+#endif
+
+void e24toasc( x, string, ndigs )
+unsigned short x[];
+char *string;
+int ndigs;
+{
+unsigned short w[NI];
+
+e24toe( x, w );
+etoasc( w, string, ndigs );
+}
+
+
+void e53toasc( x, string, ndigs )
+unsigned short x[];
+char *string;
+int ndigs;
+{
+unsigned short w[NI];
+
+e53toe( x, w );
+etoasc( w, string, ndigs );
+}
+
+
+void e64toasc( x, string, ndigs )
+unsigned short x[];
+char *string;
+int ndigs;
+{
+unsigned short w[NI];
+
+e64toe( x, w );
+etoasc( w, string, ndigs );
+}
+
+void e113toasc (x, string, ndigs)
+unsigned short x[];
+char *string;
+int ndigs;
+{
+unsigned short w[NI];
+
+e113toe (x, w);
+etoasc (w, string, ndigs);
+}
+
+
+void etoasc( x, string, ndigs )
+unsigned short x[];
+char *string;
+int ndigs;
+{
+long digit;
+unsigned short y[NI], t[NI], u[NI], w[NI];
+unsigned short *p, *r, *ten;
+unsigned short sign;
+int i, j, k, expon, rndsav;
+char *s, *ss;
+unsigned short m;
+
+rndsav = rndprc;
+#ifdef NANS
+if( eisnan(x) )
+        {
+        sprintf( string, " NaN " );
+        goto bxit;
+        }
+#endif
+rndprc = NBITS;         /* set to full precision */
+emov( x, y ); /* retain external format */
+if( y[NE-1] & 0x8000 )
+        {
+        sign = 0xffff;
+        y[NE-1] &= 0x7fff;
+        }
+else
+        {
+        sign = 0;
+        }
+expon = 0;
+ten = &etens[NTEN][0];
+emov( eone, t );
+/* Test for zero exponent */
+if( y[NE-1] == 0 )
+        {
+        for( k=0; k<NE-1; k++ )
+                {
+                if( y[k] != 0 )
+                        goto tnzro; /* denormalized number */
+                }
+        goto isone; /* legal all zeros */
+        }
+tnzro:
+
+/* Test for infinity.
+ */
+if( y[NE-1] == 0x7fff )
+        {
+        if( sign )
+                sprintf( string, " -Infinity " );
+        else
+                sprintf( string, " Infinity " );
+        goto bxit;
+        }
+
+/* Test for exponent nonzero but significand denormalized.
+ * This is an error condition.
+ */
+if( (y[NE-1] != 0) && ((y[NE-2] & 0x8000) == 0) )
+        {
+        mtherr( "etoasc", DOMAIN );
+        sprintf( string, "NaN" );
+        goto bxit;
+        }
+
+/* Compare to 1.0 */
+i = ecmp( eone, y );
+if( i == 0 )
+        goto isone;
+
+if( i < 0 )
+        { /* Number is greater than 1 */
+/* Convert significand to an integer and strip trailing decimal zeros. */
+        emov( y, u );
+        u[NE-1] = EXONE + NBITS - 1;
+
+        p = &etens[NTEN-4][0];
+        m = 16;
+do
+        {
+        ediv( p, u, t );
+        efloor( t, w );
+        for( j=0; j<NE-1; j++ )
+                {
+                if( t[j] != w[j] )
+                        goto noint;
+                }
+        emov( t, u );
+        expon += (int )m;
+noint:
+        p += NE;
+        m >>= 1;
+        }
+while( m != 0 );
+
+/* Rescale from integer significand */
+        u[NE-1] += y[NE-1] - (unsigned int )(EXONE + NBITS - 1);
+        emov( u, y );
+/* Find power of 10 */
+        emov( eone, t );
+        m = MAXP;
+        p = &etens[0][0];
+        while( ecmp( ten, u ) <= 0 )
+                {
+                if( ecmp( p, u ) <= 0 )
+                        {
+                        ediv( p, u, u );
+                        emul( p, t, t );
+                        expon += (int )m;
+                        }
+                m >>= 1;
+                if( m == 0 )
+                        break;
+                p += NE;
+                }
+        }
+else
+        { /* Number is less than 1.0 */
+/* Pad significand with trailing decimal zeros. */
+        if( y[NE-1] == 0 )
+                {
+                while( (y[NE-2] & 0x8000) == 0 )
+                        {
+                        emul( ten, y, y );
+                        expon -= 1;
+                        }
+                }
+        else
+                {
+                emovi( y, w );
+                for( i=0; i<NDEC+1; i++ )
+                        {
+                        if( (w[NI-1] & 0x7) != 0 )
+                                break;
+/* multiply by 10 */
+                        emovz( w, u );
+                        eshdn1( u );
+                        eshdn1( u );
+                        eaddm( w, u );
+                        u[1] += 3;
+                        while( u[2] != 0 )
+                                {
+                                eshdn1(u);
+                                u[1] += 1;
+                                }
+                        if( u[NI-1] != 0 )
+                                break;
+                        if( eone[NE-1] <= u[1] )
+                                break;
+                        emovz( u, w );
+                        expon -= 1;
+                        }
+                emovo( w, y );
+                }
+        k = -MAXP;
+        p = &emtens[0][0];
+        r = &etens[0][0];
+        emov( y, w );
+        emov( eone, t );
+        while( ecmp( eone, w ) > 0 )
+                {
+                if( ecmp( p, w ) >= 0 )
+                        {
+                        emul( r, w, w );
+                        emul( r, t, t );
+                        expon += k;
+                        }
+                k /= 2;
+                if( k == 0 )
+                        break;
+                p += NE;
+                r += NE;
+                }
+        ediv( t, eone, t );
+        }
+isone:
+/* Find the first (leading) digit. */
+emovi( t, w );
+emovz( w, t );
+emovi( y, w );
+emovz( w, y );
+eiremain( t, y );
+digit = equot[NI-1];
+while( (digit == 0) && (ecmp(y,ezero) != 0) )
+        {
+        eshup1( y );
+        emovz( y, u );
+        eshup1( u );
+        eshup1( u );
+        eaddm( u, y );
+        eiremain( t, y );
+        digit = equot[NI-1];
+        expon -= 1;
+        }
+s = string;
+if( sign )
+        *s++ = '-';
+else
+        *s++ = ' ';
+/* Examine number of digits requested by caller. */
+if( ndigs < 0 )
+        ndigs = 0;
+if( ndigs > NDEC )
+        ndigs = NDEC;
+if( digit == 10 )
+        {
+        *s++ = '1';
+        *s++ = '.';
+        if( ndigs > 0 )
+                {
+                *s++ = '0';
+                ndigs -= 1;
+                }
+        expon += 1;
+        }
+else
+        {
+        *s++ = (char )digit + '0';
+        *s++ = '.';
+        }
+/* Generate digits after the decimal point. */
+for( k=0; k<=ndigs; k++ )
+        {
+/* multiply current number by 10, without normalizing */
+        eshup1( y );
+        emovz( y, u );
+        eshup1( u );
+        eshup1( u );
+        eaddm( u, y );
+        eiremain( t, y );
+        *s++ = (char )equot[NI-1] + '0';
+        }
+digit = equot[NI-1];
+--s;
+ss = s;
+/* round off the ASCII string */
+if( digit > 4 )
+        {
+/* Test for critical rounding case in ASCII output. */
+        if( digit == 5 )
+                {
+                emovo( y, t );
+                if( ecmp(t,ezero) != 0 )
+                        goto roun;      /* round to nearest */
+                if( (*(s-1) & 1) == 0 )
+                        goto doexp;     /* round to even */
+                }
+/* Round up and propagate carry-outs */
+roun:
+        --s;
+        k = *s & 0x7f;
+/* Carry out to most significant digit? */
+        if( k == '.' )
+                {
+                --s;
+                k = *s;
+                k += 1;
+                *s = (char )k;
+/* Most significant digit carries to 10? */
+                if( k > '9' )
+                        {
+                        expon += 1;
+                        *s = '1';
+                        }
+                goto doexp;
+                }
+/* Round up and carry out from less significant digits */
+        k += 1;
+        *s = (char )k;
+        if( k > '9' )
+                {
+                *s = '0';
+                goto roun;
+                }
+        }
+doexp:
+/*
+if( expon >= 0 )
+        sprintf( ss, "e+%d", expon );
+else
+        sprintf( ss, "e%d", expon );
+*/
+        sprintf( ss, "E%d", expon );
+bxit:
+rndprc = rndsav;
+}
+
+
+
+
+/*
+;                                                               ASCTOQ
+;               ASCTOQ.MAC              LATEST REV: 11 JAN 84
+;                                       SLM, 3 JAN 78
+;
+;       Convert ASCII string to quadruple precision floating point
+;
+;               Numeric input is free field decimal number
+;               with max of 15 digits with or without 
+;               decimal point entered as ASCII from teletype.
+;       Entering E after the number followed by a second
+;       number causes the second number to be interpreted
+;       as a power of 10 to be multiplied by the first number
+;       (i.e., "scientific" notation).
+;
+;       Usage:
+;               asctoq( string, q );
+*/
+
+/* ASCII to single */
+void asctoe24( s, y )
+char *s;
+unsigned short *y;
+{
+asctoeg( s, y, 24 );
+}
+
+
+/* ASCII to double */
+void asctoe53( s, y )
+char *s;
+unsigned short *y;
+{
+#ifdef DEC
+asctoeg( s, y, 56 );
+#else
+asctoeg( s, y, 53 );
+#endif
+}
+
+
+/* ASCII to long double */
+void asctoe64( s, y )
+char *s;
+unsigned short *y;
+{
+asctoeg( s, y, 64 );
+}
+
+/* ASCII to 128-bit long double */
+void asctoe113 (s, y)
+char *s;
+unsigned short *y;
+{
+asctoeg( s, y, 113 );
+}
+
+/* ASCII to super double */
+void asctoe( s, y )
+char *s;
+unsigned short *y;
+{
+asctoeg( s, y, NBITS );
+}
+
+/* Space to make a copy of the input string: */
+static char lstr[82] = {0};
+
+void asctoeg( ss, y, oprec )
+char *ss;
+unsigned short *y;
+int oprec;
+{
+unsigned short yy[NI], xt[NI], tt[NI];
+int esign, decflg, sgnflg, nexp, exp, prec, lost;
+int k, trail, c, rndsav;
+long lexp;
+unsigned short nsign, *p;
+char *sp, *s;
+
+/* Copy the input string. */
+s = ss;
+while( *s == ' ' ) /* skip leading spaces */
+        ++s;
+sp = lstr;
+for( k=0; k<79; k++ )
+        {
+        if( (*sp++ = *s++) == '\0' )
+                break;
+        }
+*sp = '\0';
+s = lstr;
+
+rndsav = rndprc;
+rndprc = NBITS; /* Set to full precision */
+lost = 0;
+nsign = 0;
+decflg = 0;
+sgnflg = 0;
+nexp = 0;
+exp = 0;
+prec = 0;
+ecleaz( yy );
+trail = 0;
+
+nxtcom:
+k = *s - '0';
+if( (k >= 0) && (k <= 9) )
+        {
+/* Ignore leading zeros */
+        if( (prec == 0) && (decflg == 0) && (k == 0) )
+                goto donchr;
+/* Identify and strip trailing zeros after the decimal point. */
+        if( (trail == 0) && (decflg != 0) )
+                {
+                sp = s;
+                while( (*sp >= '0') && (*sp <= '9') )
+                        ++sp;
+/* Check for syntax error */
+                c = *sp & 0x7f;
+                if( (c != 'e') && (c != 'E') && (c != '\0')
+                        && (c != '\n') && (c != '\r') && (c != ' ')
+                        && (c != ',') )
+                        goto error;
+                --sp;
+                while( *sp == '0' )
+                        *sp-- = 'z';
+                trail = 1;
+                if( *s == 'z' )
+                        goto donchr;
+                }
+/* If enough digits were given to more than fill up the yy register,
+ * continuing until overflow into the high guard word yy[2]
+ * guarantees that there will be a roundoff bit at the top
+ * of the low guard word after normalization.
+ */
+        if( yy[2] == 0 )
+                {
+                if( decflg )
+                        nexp += 1; /* count digits after decimal point */
+                eshup1( yy );   /* multiply current number by 10 */
+                emovz( yy, xt );
+                eshup1( xt );
+                eshup1( xt );
+                eaddm( xt, yy );
+                ecleaz( xt );
+                xt[NI-2] = (unsigned short )k;
+                eaddm( xt, yy );
+                }
+        else
+                {
+                /* Mark any lost non-zero digit.  */
+                lost |= k;
+                /* Count lost digits before the decimal point.  */
+                if (decflg == 0)
+                        nexp -= 1;
+                }
+        prec += 1;
+        goto donchr;
+        }
+
+switch( *s )
+        {
+        case 'z':
+                break;
+        case 'E':
+        case 'e':
+                goto expnt;
+        case '.':       /* decimal point */
+                if( decflg )
+                        goto error;
+                ++decflg;
+                break;
+        case '-':
+                nsign = 0xffff;
+                if( sgnflg )
+                        goto error;
+                ++sgnflg;
+                break;
+        case '+':
+                if( sgnflg )
+                        goto error;
+                ++sgnflg;
+                break;
+        case ',':
+        case ' ':
+        case '\0':
+        case '\n':
+        case '\r':
+                goto daldone;
+        case 'i':
+        case 'I':
+                goto infinite;
+        default:
+        error:
+#ifdef NANS
+                enan( yy, NI*16 );
+#else
+                mtherr( "asctoe", DOMAIN );
+                ecleaz(yy);
+#endif
+                goto aexit;
+        }
+donchr:
+++s;
+goto nxtcom;
+
+/* Exponent interpretation */
+expnt:
+
+esign = 1;
+exp = 0;
+++s;
+/* check for + or - */
+if( *s == '-' )
+        {
+        esign = -1;
+        ++s;
+        }
+if( *s == '+' )
+        ++s;
+while( (*s >= '0') && (*s <= '9') )
+        {
+        exp *= 10;
+        exp += *s++ - '0';
+        if (exp > 4977)
+                {
+                if (esign < 0)
+                        goto zero;
+                else
+                        goto infinite;
+                }
+        }
+if( esign < 0 )
+        exp = -exp;
+if( exp > 4932 )
+        {
+infinite:
+        ecleaz(yy);
+        yy[E] = 0x7fff;  /* infinity */
+        goto aexit;
+        }
+if( exp < -4977 )
+        {
+zero:
+        ecleaz(yy);
+        goto aexit;
+        }
+
+daldone:
+nexp = exp - nexp;
+/* Pad trailing zeros to minimize power of 10, per IEEE spec. */
+while( (nexp > 0) && (yy[2] == 0) )
+        {
+        emovz( yy, xt );
+        eshup1( xt );
+        eshup1( xt );
+        eaddm( yy, xt );
+        eshup1( xt );
+        if( xt[2] != 0 )
+                break;
+        nexp -= 1;
+        emovz( xt, yy );
+        }
+if( (k = enormlz(yy)) > NBITS )
+        {
+        ecleaz(yy);
+        goto aexit;
+        }
+lexp = (EXONE - 1 + NBITS) - k;
+emdnorm( yy, lost, 0, lexp, 64 );
+/* convert to external format */
+
+
+/* Multiply by 10**nexp.  If precision is 64 bits,
+ * the maximum relative error incurred in forming 10**n
+ * for 0 <= n <= 324 is 8.2e-20, at 10**180.
+ * For 0 <= n <= 999, the peak relative error is 1.4e-19 at 10**947.
+ * For 0 >= n >= -999, it is -1.55e-19 at 10**-435.
+ */
+lexp = yy[E];
+if( nexp == 0 )
+        {
+        k = 0;
+        goto expdon;
+        }
+esign = 1;
+if( nexp < 0 )
+        {
+        nexp = -nexp;
+        esign = -1;
+        if( nexp > 4096 )
+                { /* Punt.  Can't handle this without 2 divides. */
+                emovi( etens[0], tt );
+                lexp -= tt[E];
+                k = edivm( tt, yy );
+                lexp += EXONE;
+                nexp -= 4096;
+                }
+        }
+p = &etens[NTEN][0];
+emov( eone, xt );
+exp = 1;
+do
+        {
+        if( exp & nexp )
+                emul( p, xt, xt );
+        p -= NE;
+        exp = exp + exp;
+        }
+while( exp <= MAXP );
+
+emovi( xt, tt );
+if( esign < 0 )
+        {
+        lexp -= tt[E];
+        k = edivm( tt, yy );
+        lexp += EXONE;
+        }
+else
+        {
+        lexp += tt[E];
+        k = emulm( tt, yy );
+        lexp -= EXONE - 1;
+        }
+
+expdon:
+
+/* Round and convert directly to the destination type */
+if( oprec == 53 )
+        lexp -= EXONE - 0x3ff;
+else if( oprec == 24 )
+        lexp -= EXONE - 0177;
+#ifdef DEC
+else if( oprec == 56 )
+        lexp -= EXONE - 0201;
+#endif
+rndprc = oprec;
+emdnorm( yy, k, 0, lexp, 64 );
+
+aexit:
+
+rndprc = rndsav;
+yy[0] = nsign;
+switch( oprec )
+        {
+#ifdef DEC
+        case 56:
+                todec( yy, y ); /* see etodec.c */
+                break;
+#endif
+        case 53:
+                toe53( yy, y );
+                break;
+        case 24:
+                toe24( yy, y );
+                break;
+        case 64:
+                toe64( yy, y );
+                break;
+        case 113:
+                toe113( yy, y );
+                break;
+        case NBITS:
+                emovo( yy, y );
+                break;
+        }
+}
+
+
+ 
+/* y = largest integer not greater than x
+ * (truncated toward minus infinity)
+ *
+ * unsigned short x[NE], y[NE]
+ *
+ * efloor( x, y );
+ */
+static unsigned short bmask[] = {
+0xffff,
+0xfffe,
+0xfffc,
+0xfff8,
+0xfff0,
+0xffe0,
+0xffc0,
+0xff80,
+0xff00,
+0xfe00,
+0xfc00,
+0xf800,
+0xf000,
+0xe000,
+0xc000,
+0x8000,
+0x0000,
+};
+
+void efloor( x, y )
+unsigned short x[], y[];
+{
+register unsigned short *p;
+int e, expon, i;
+unsigned short f[NE];
+
+emov( x, f ); /* leave in external format */
+expon = (int )f[NE-1];
+e = (expon & 0x7fff) - (EXONE - 1);
+if( e <= 0 )
+        {
+        eclear(y);
+        goto isitneg;
+        }
+/* number of bits to clear out */
+e = NBITS - e;
+emov( f, y );
+if( e <= 0 )
+        return;
+
+p = &y[0];
+while( e >= 16 )
+        {
+        *p++ = 0;
+        e -= 16;
+        }
+/* clear the remaining bits */
+*p &= bmask[e];
+/* truncate negatives toward minus infinity */
+isitneg:
+
+if( (unsigned short )expon & (unsigned short )0x8000 )
+        {
+        for( i=0; i<NE-1; i++ )
+                {
+                if( f[i] != y[i] )
+                        {
+                        esub( eone, y, y );
+                        break;
+                        }
+                }
+        }
+}
+
+
+/* unsigned short x[], s[];
+ * long *exp;
+ *
+ * efrexp( x, exp, s );
+ *
+ * Returns s and exp such that  s * 2**exp = x and .5 <= s < 1.
+ * For example, 1.1 = 0.55 * 2**1
+ * Handles denormalized numbers properly using long integer exp.
+ */
+void efrexp( x, exp, s )
+unsigned short x[];
+long *exp;
+unsigned short s[];
+{
+unsigned short xi[NI];
+long li;
+
+emovi( x, xi );
+li = (long )((short )xi[1]);
+
+if( li == 0 )
+        {
+        li -= enormlz( xi );
+        }
+xi[1] = 0x3ffe;
+emovo( xi, s );
+*exp = li - 0x3ffe;
+}
+
+
+
+/* unsigned short x[], y[];
+ * long pwr2;
+ *
+ * eldexp( x, pwr2, y );
+ *
+ * Returns y = x * 2**pwr2.
+ */
+void eldexp( x, pwr2, y )
+unsigned short x[];
+long pwr2;
+unsigned short y[];
+{
+unsigned short xi[NI];
+long li;
+int i;
+
+emovi( x, xi );
+li = xi[1];
+li += pwr2;
+i = 0;
+emdnorm( xi, i, i, li, 64 );
+emovo( xi, y );
+}
+
+
+/* c = remainder after dividing b by a
+ * Least significant integer quotient bits left in equot[].
+ */
+void eremain( a, b, c )
+unsigned short a[], b[], c[];
+{
+unsigned short den[NI], num[NI];
+
+#ifdef NANS
+if( eisinf(b) || (ecmp(a,ezero) == 0) || eisnan(a) || eisnan(b))
+        {
+        enan( c, NBITS );
+        return;
+        }
+#endif
+if( ecmp(a,ezero) == 0 )
+        {
+        mtherr( "eremain", SING );
+        eclear( c );
+        return;
+        }
+emovi( a, den );
+emovi( b, num );
+eiremain( den, num );
+/* Sign of remainder = sign of quotient */
+if( a[0] == b[0] )
+        num[0] = 0;
+else
+        num[0] = 0xffff;
+emovo( num, c );
+}
+
+
+void eiremain( den, num )
+unsigned short den[], num[];
+{
+long ld, ln;
+unsigned short j;
+
+ld = den[E];
+ld -= enormlz( den );
+ln = num[E];
+ln -= enormlz( num );
+ecleaz( equot );
+while( ln >= ld )
+        {
+        if( ecmpm(den,num) <= 0 )
+                {
+                esubm(den, num);
+                j = 1;
+                }
+        else
+                {
+                j = 0;
+                }
+        eshup1(equot);
+        equot[NI-1] |= j;
+        eshup1(num);
+        ln -= 1;
+        }
+emdnorm( num, 0, 0, ln, 0 );
+}
+
+/* NaN bit patterns
+ */
+#ifdef MIEEE
+unsigned short nan113[8] = {
+  0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};
+unsigned short nan64[6] = {0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};
+unsigned short nan53[4] = {0x7fff, 0xffff, 0xffff, 0xffff};
+unsigned short nan24[2] = {0x7fff, 0xffff};
+#endif
+
+#ifdef IBMPC
+unsigned short nan113[8] = {0, 0, 0, 0, 0, 0, 0xc000, 0xffff};
+unsigned short nan64[6] = {0, 0, 0, 0xc000, 0xffff, 0};
+unsigned short nan53[4] = {0, 0, 0, 0xfff8};
+unsigned short nan24[2] = {0, 0xffc0};
+#endif
+
+
+void enan (nan, size)
+unsigned short *nan;
+int size;
+{
+int i, n;
+unsigned short *p;
+
+switch( size )
+        {
+#ifndef DEC
+        case 113:
+        n = 8;
+        p = nan113;
+        break;
+
+        case 64:
+        n = 6;
+        p = nan64;
+        break;
+
+        case 53:
+        n = 4;
+        p = nan53;
+        break;
+
+        case 24:
+        n = 2;
+        p = nan24;
+        break;
+
+        case NBITS:
+        for( i=0; i<NE-2; i++ )
+                *nan++ = 0;
+        *nan++ = 0xc000;
+        *nan++ = 0x7fff;
+        return;
+
+        case NI*16:
+        *nan++ = 0;
+        *nan++ = 0x7fff;
+        *nan++ = 0;
+        *nan++ = 0xc000;
+        for( i=4; i<NI; i++ )
+                *nan++ = 0;
+        return;
+#endif
+        default:
+        mtherr( "enan", DOMAIN );
+        return;
+        }
+for (i=0; i < n; i++)
+        *nan++ = *p++;
+}
+
+
+
+/* Longhand square root. */
+
+static int esqinited = 0;
+static unsigned short sqrndbit[NI];
+
+void esqrt( x, y )
+short *x, *y;
+{
+unsigned short temp[NI], num[NI], sq[NI], xx[NI];
+int i, j, k, n, nlups;
+long m, exp;
+
+if( esqinited == 0 )
+        {
+        ecleaz( sqrndbit );
+        sqrndbit[NI-2] = 1;
+        esqinited = 1;
+        }
+/* Check for arg <= 0 */
+i = ecmp( x, ezero );
+if( i <= 0 )
+        {
+#ifdef NANS
+        if (i == -2)
+                {
+                enan (y, NBITS);
+                return;
+                }
+#endif
+        eclear(y);
+        if( i < 0 )
+                mtherr( "esqrt", DOMAIN );
+        return;
+        }
+
+#ifdef INFINITY
+if( eisinf(x) )
+        {
+        eclear(y);
+        einfin(y);
+        return;
+        }
+#endif
+/* Bring in the arg and renormalize if it is denormal. */
+emovi( x, xx );
+m = (long )xx[1]; /* local long word exponent */
+if( m == 0 )
+        m -= enormlz( xx );
+
+/* Divide exponent by 2 */
+m -= 0x3ffe;
+exp = (unsigned short )( (m / 2) + 0x3ffe );
+
+/* Adjust if exponent odd */
+if( (m & 1) != 0 )
+        {
+        if( m > 0 )
+                exp += 1;
+        eshdn1( xx );
+        }
+
+ecleaz( sq );
+ecleaz( num );
+n = 8; /* get 8 bits of result per inner loop */
+nlups = rndprc;
+j = 0;
+
+while( nlups > 0 )
+        {
+/* bring in next word of arg */
+        if( j < NE )
+                num[NI-1] = xx[j+3];
+/* Do additional bit on last outer loop, for roundoff. */
+        if( nlups <= 8 )
+                n = nlups + 1;
+        for( i=0; i<n; i++ )
+                {
+/* Next 2 bits of arg */
+                eshup1( num );
+                eshup1( num );
+/* Shift up answer */
+                eshup1( sq );
+/* Make trial divisor */
+                for( k=0; k<NI; k++ )
+                        temp[k] = sq[k];
+                eshup1( temp );
+                eaddm( sqrndbit, temp );
+/* Subtract and insert answer bit if it goes in */
+                if( ecmpm( temp, num ) <= 0 )
+                        {
+                        esubm( temp, num );
+                        sq[NI-2] |= 1;
+                        }
+                }
+        nlups -= n;
+        j += 1;
+        }
+
+/* Adjust for extra, roundoff loop done. */
+exp += (NBITS - 1) - rndprc;
+
+/* Sticky bit = 1 if the remainder is nonzero. */
+k = 0;
+for( i=3; i<NI; i++ )
+        k |= (int )num[i];
+
+/* Renormalize and round off. */
+emdnorm( sq, k, 0, exp, 64 );
+emovo( sq, y );
+}
diff --git a/src/regress/lib/libc/cephes/ieetst.c b/src/regress/lib/libc/cephes/ieetst.c
new file mode 100644
index 0000000000..41dfd6a96e
--- /dev/null
+++ b/src/regress/lib/libc/cephes/ieetst.c
@@ -0,0 +1,880 @@
+/*      $OpenBSD: ieetst.c,v 1.2 2011/07/03 13:39:07 martynas Exp $     */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* Floating point to ASCII input and output string test program.
+ *
+ * Numbers in the native machine data structure are converted
+ * to e type, then to and from decimal ASCII strings.  Native
+ * printf() and scanf() functions are also used to produce
+ * and read strings.  The resulting e type binary values
+ * are compared, with diagnostic printouts of any discrepancies.
+ *
+ * Steve Moshier, 16 Dec 88
+ * last revision: 16 May 92
+ */
+
+#include <float.h>
+#include <stdio.h>
+
+#include "mconf.h"
+#include "ehead.h"
+
+/* Include tests of 80-bit long double precision: */
+#if     LDBL_MANT_DIG == 64
+#define LDOUBLE 1
+#else   /* LDBL_MANT_DIG == 64 */
+#define LDOUBLE 0
+#endif  /* LDBL_MANT_DIG == 64 */
+/* Abort subtest after getting this many errors: */
+#define MAXERR 5
+/* Number of random arguments to try (set as large as you have
+ * patience for): */
+#define NRAND 100
+/* Perform internal consistency test: */
+#define CHKINTERNAL 0
+
+static unsigned short fullp[NE], rounded[NE];
+float prec24, sprec24, ssprec24;
+double prec53, sprec53, ssprec53;
+#if LDOUBLE
+long double prec64, sprec64, ssprec64;
+#endif
+
+static unsigned short rprint[NE], rscan[NE];
+static unsigned short q1[NE], q2[NE], q5[NE];
+static unsigned short e1[NE], e2[NE], e3[NE];
+static double d1, d2;
+static int errprint = 0;
+static int errscan = 0;
+static int identerr = 0;
+static int errtot = 0;
+static int count = 0;
+static char str0[80], str1[80], str2[80], str3[80];
+static unsigned short eten[NE], maxm[NE];
+
+int m, n, k2, mprec, SPREC;
+
+char *Ten = "10.0";
+char tformat[10];
+char *format24 = "%.8e";
+#ifdef DEC
+char *format53 = "%.17e";
+#else
+char *format53 = "%.16e";
+#endif
+char *fformat24 = "%e";
+char *fformat53 = "%le";
+char *pct = "%";
+char *quo = "\042";
+#if LDOUBLE
+char *format64 = "%.20Le";
+char *fformat64 = "%Le";
+#endif
+char *format;
+char *fformat;
+char *toomany = "Too many errors; aborting this test.\n";
+
+static int mnrflag;
+static int etrflag;
+void chkit(), printerr(), mnrand(), etrand(), shownoncrit();
+void chkid(), pvec();
+
+main()
+{
+int i, iprec, retval = 0;
+
+printf( "Steve Moshier's printf/scanf tester, version 0.2.\n\n" );
+#ifdef DEC
+ /* DEC PDP-11/VAX single precision not yet implemented */
+for( iprec = 1; iprec<2; iprec++ )
+#else
+for( iprec = 0; iprec<3; iprec++ )
+/*for( iprec = 2; iprec<3; iprec++ )*/
+#endif
+        {
+        errscan = 0;
+        identerr = 0;
+        errprint = 0;
+        eclear( rprint );
+        eclear( rscan );
+
+switch( iprec )
+        {
+        case 0:
+                SPREC = 8; /* # digits after the decimal point */
+                mprec = 24; /* # bits in the significand */
+                m = 9; /* max # decimal digits for correct rounding */
+                n = 13; /* max power of ten for correct rounding */
+                k2 = -125; /* underflow beyond 2^-k2 */
+                format = format24; /* printf format string */
+                fformat = fformat24; /* scanf format string */
+                mnrflag = 1; /* sets interval for random numbers */
+                etrflag = 1;
+                printf( "Testing FLOAT precision.\n" );
+                break;
+
+        case 1:
+#ifdef DEC
+                SPREC = 17;
+                mprec = 56;
+                m = 17;
+                n = 27;
+                k2 = -125;
+                format = format53;
+                fformat = fformat53;
+                mnrflag = 2;
+                etrflag = 1;
+                printf( "Testing DEC DOUBLE precision.\n" );
+                break;
+#else
+                SPREC = 16;
+                mprec = 53;
+                m = 17;
+                n = 27;
+                k2 = -1021;
+                format = format53;
+                fformat = fformat53;
+                mnrflag = 2;
+                etrflag = 2;
+                printf( "Testing DOUBLE precision.\n" );
+                break;
+#endif
+        case 2:
+#if LDOUBLE
+                SPREC = 20;
+                mprec = 64;
+                m = 20;
+                n = 34;
+                k2 = -16382;
+                format = format64;
+                fformat = fformat64;
+                mnrflag = 3;
+                etrflag = 3;
+                printf( "Testing LONG DOUBLE precision.\n" );
+                break;
+#else
+                goto nodenorm;
+#endif
+        }
+
+        asctoe( Ten, eten );
+/* 10^m - 1 */
+        d2 = m;
+        e53toe( &d2, e1 );
+        epow( eten, e1, maxm );
+        esub( eone, maxm, maxm );
+
+/* test 1 */
+        printf( "1. Checking 10^n - 1 for n = %d to %d.\n", -m, m );
+        emov( eone, q5 );
+        for( count=0; count<=m; count++ )
+                {
+                esub( eone, q5, fullp );
+                chkit( 1 );
+                ediv( q5, eone, q2 );
+                esub( eone, q2, fullp );
+                chkit( 1 );
+                emul( eten, q5, q5 );
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto end1;
+                        }
+                }
+end1:
+        printerr();
+
+
+/* test 2 */
+        printf( "2. Checking powers of 10 from 10^-%d to 10^%d.\n", n, n );
+        emov( eone, q5 );
+        for( count=0; count<=n; count++ )
+                {
+                emov( q5, fullp );
+                chkit( 2 );
+                ediv( q5, eone, fullp );
+                chkit( 2 );
+                emul( eten, q5, q5 );
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto end2;
+                        }
+                }
+end2:
+        printerr();
+
+/* test 3 */
+        printf( "3. Checking (10^%d-1)*10^n from n = -%d to %d.\n", m, n, n );
+        emov( eone, q5 );
+        for( count= -n; count<=n; count++ )
+                {
+                emul( maxm, q5, fullp );
+                chkit( 3 );
+                emov( q5, fullp );
+                ediv( fullp, eone, fullp );
+                emul( maxm, fullp, fullp );
+                chkit( 3 );
+                emul( eten, q5, q5 );
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto end3;
+                        }
+                }
+end3:
+        printerr();
+
+
+
+/* test 4 */
+        printf( "4. Checking powers of 2 from 2^-24 to 2^+56.\n" );
+        d1 = -24.0;
+        e53toe( &d1, q1 );
+        epow( etwo, q1, q5 );
+
+        for( count = -24; count <= 56; count++ )
+                {
+                emov( q5, fullp );
+                chkit( 4 );
+                emul( etwo, q5, q5 );
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto end4;
+                        }
+                }
+end4:
+        printerr();
+
+
+/* test 5 */
+        printf( "5. Checking 2^n - 1 for n = 0 to %d.\n", mprec );
+        emov( eone, q5 );
+        for( count=0; count<=mprec; count++ )
+                {
+                esub( eone, q5, fullp );
+                chkit( 5 );
+                emul( etwo, q5, q5 );
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto end5;
+                        }
+                }
+end5:
+        printerr();
+
+/* test 6 */
+        printf( "6. Checking 2^n + 1 for n = 0 to %d.\n", mprec );
+        emov( eone, q5 );
+        for( count=0; count<=mprec; count++ )
+                {
+                eadd( eone, q5, fullp );
+                chkit( 6 );
+                emul( etwo, q5, q5 );
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto end6;
+                        }
+                }
+end6:
+        printerr();
+
+/* test 7 */
+        printf(
+         "7. Checking %d values M * 10^N with random integer M and N,\n",
+         NRAND );
+        printf("  1 <= M <= 10^%d - 1  and  -%d <= N <= +%d.\n", m, n, n );
+        for( i=0; i<NRAND; i++ )
+                {
+                mnrand( fullp );
+                chkit( 7 );
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto end7;
+                        }
+                }
+end7:
+        printerr();
+
+/* test 8 */
+        printf("8. Checking critical rounding cases.\n" );
+        for( i=0; i<20; i++ )
+                {
+                mnrand( fullp );
+                eabs( fullp );
+                if( ecmp( fullp, eone ) < 0 )
+                        ediv( fullp, eone, fullp );
+                efloor( fullp, fullp );
+                eadd( ehalf, fullp, fullp );
+                chkit( 8 );
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto end8;
+                        }
+                }
+end8:
+        printerr();
+
+
+
+/* test 9 */
+        printf("9. Testing on %d random non-denormal values.\n", NRAND );
+        for( i=0; i<NRAND; i++ )
+                {
+                etrand( fullp );
+                chkit( 9 );
+                }
+        printerr();
+        shownoncrit();
+
+/* test 10 */
+#if 0
+        printf(
+        "Do you want to check denormal numbers in this precision ? (y/n) " );
+        gets( str0 );
+        if( str0[0] != 'y' )
+                goto nodenorm;
+#endif
+
+        printf( "10. Checking denormal numbers.\n" );
+
+/* Form 2^-starting power */
+        d1 = k2;
+        e53toe( &d1, q1 );
+        epow( etwo, q1, e1 );
+
+/* Find 2^-mprec less than starting power */
+        d1 = -mprec + 4;
+        e53toe( &d1, q1 );
+        epow( etwo, q1, e3 );
+        emul( e1, e3, e3 );
+        emov( e3, e2 );
+        ediv( etwo, e2, e2 );
+
+        while( ecmp(e1,e2) != 0 )
+                {
+                eadd( e1, e2, fullp );
+                switch( mprec )
+                        {
+#if LDOUBLE
+                        case 64:
+                        etoe64( e1, &sprec64 );
+                        e64toe( &sprec64, q1 );
+                        etoe64( fullp, &prec64 );
+                        e64toe( &prec64, q2 );
+                        break;
+#endif
+#ifdef DEC
+                        case 56:
+#endif
+                        case 53:
+                        etoe53( e1, &sprec53 );
+                        e53toe( &sprec53, q1 );
+                        etoe53( fullp, &prec53 );
+                        e53toe( &prec53, q2 );
+                        break;
+
+                        case 24:
+                        etoe24( e1, &sprec24 );
+                        e24toe( &sprec24, q1 );
+                        etoe24( fullp, &prec24 );
+                        e24toe( &prec24, q2 );
+                        break;
+                        }
+                if( ecmp( q2, ezero ) == 0 )
+                        goto maxden;
+                chkit(10);
+                if( ecmp(q1,q2) == 0 )
+                        {
+                        ediv( etwo, e1, e1 );
+                        emov( e3, e2 );
+                        }
+                if( errtot >= MAXERR )
+                        {
+                        printf( "%s", toomany );
+                        goto maxden;
+                        }
+                ediv( etwo, e2, e2 );
+                }
+maxden:
+        printerr();
+nodenorm:
+        printf( "\n" );
+        retval |= errscan | identerr | errprint;
+        } /* loop on precision */
+printf( "End of test.\n" );
+return (retval);
+}
+
+#if CHKINTERNAL
+long double xprec64;
+double xprec53;
+float xprec24;
+
+/* Check binary -> printf -> scanf -> binary identity
+ * of internal routines
+ */
+void chkinternal( ref, tst, string )
+unsigned short ref[], tst[];
+char *string;
+{
+
+if( ecmp(ref,tst) != 0 )
+        {
+        printf( "internal identity compare error!\n" );
+        chkid( ref, tst, string );
+        }
+}
+#endif
+
+
+/* Check binary -> printf -> scanf -> binary identity
+ */
+void chkid( print, scan, string )
+unsigned short print[], scan[];
+char *string;
+{
+/* Test printf-scanf identity */
+if( ecmp( print, scan ) != 0 )
+        {
+        pvec( print, NE );
+        printf( " ->printf-> %s ->scanf->\n", string );
+        pvec( scan, NE );
+        printf( " is not an identity.\n" );
+        ++identerr;
+        }
+}
+
+
+/* Check scanf result
+ */
+void chkscan( ref, tst, string )
+unsigned short ref[], tst[];
+char *string;
+{
+/* Test scanf()  */
+if( ecmp( ref, tst ) != 0 )
+        {
+        printf( "scanf(%s) -> ", string );
+        pvec( tst, NE );
+        printf( "\n should be    " );
+        pvec( ref, NE );
+        printf( ".\n" );
+        ++errscan;
+        ++errtot;
+        }
+}
+
+
+/* Test printf() result
+ */
+void chkprint( ref, tst, string ) 
+unsigned short ref[], tst[];
+char *string;
+{
+if( ecmp(ref, tst) != 0 )
+        {
+        printf( "printf( ");
+        pvec( ref, NE );
+        printf( ") -> %s\n", string );
+        printf( "      = " );
+        pvec( tst, NE );
+        printf( ".\n" );
+        ++errprint;
+        ++errtot;
+        }
+}
+
+
+/* Print array of n 16-bit shorts
+ */
+void pvec( x, n )
+unsigned short x[];
+int n;
+{
+int i;
+
+for( i=0; i<n; i++ )
+        {
+        printf( "%04x ", x[i] );
+        }
+}
+
+/* Measure worst case printf rounding error
+ */
+void cmpprint( ref, tst )
+unsigned short ref[], tst[];
+{
+unsigned short e[NE];
+
+if( ecmp( ref, ezero ) != 0 )
+        {
+        esub( ref, tst, e );
+        ediv( ref, e, e );
+        eabs( e );
+        if( ecmp( e, rprint ) > 0 )
+                emov( e, rprint );
+        }
+}
+
+/* Measure worst case scanf rounding error
+ */
+void cmpscan( ref, tst )
+unsigned short ref[], tst[];
+{
+unsigned short er[NE];
+
+if( ecmp( ref, ezero ) != 0 )
+        {
+        esub( ref, tst, er );
+        ediv( ref, er, er );
+        eabs( er );
+        if( ecmp( er, rscan ) > 0 )
+                emov( er, rscan );
+        if( ecmp( er, ehalf ) > 0 )
+                {
+                etoasc( tst, str1, 21 );
+                printf( "Bad error: scanf(%s) = %s !\n", str0, str1 );
+                }
+        }
+}
+
+/* Check rounded-down decimal string output of printf
+ */
+void cmptrunc( ref, tst )
+unsigned short ref[], tst[];
+{
+if( ecmp( ref, tst ) != 0 )
+        {
+        printf( "printf(%s%s%s, %s) -> %s\n", quo, tformat, quo, str1, str2 );
+        printf( "should be      %s .\n", str3 );
+        errprint += 1;
+        }
+}
+
+
+void shownoncrit()
+{
+
+etoasc( rprint, str0, 3 );
+printf( "Maximum relative printf error found = %s .\n", str0 );
+etoasc( rscan, str0, 3 );
+printf( "Maximum relative scanf error found = %s .\n", str0 );
+}
+
+
+
+/* Produce arguments and call comparison subroutines.
+ */
+void chkit( testno )
+int testno;
+{
+unsigned short t[NE], u[NE], v[NE];
+int j;
+
+switch( mprec )
+        {
+#if LDOUBLE
+        case 64:
+                etoe64( fullp, &prec64 );
+                e64toe( &prec64, rounded );
+#if CHKINTERNAL
+                e64toasc( &prec64, str1, SPREC );
+                asctoe64( str1, &xprec64 );
+                e64toe( &xprec64, t );
+                chkinternal( rounded, t, str1 );
+#endif
+/* check printf and scanf */
+                sprintf( str2, format, prec64 );
+                sscanf( str2, fformat, &sprec64 );
+                e64toe( &sprec64, u );
+                chkid( rounded, u, str2 );
+                asctoe64( str2, &ssprec64 );
+                e64toe( &ssprec64, v );
+                chkscan( v, u, str2 );
+                chkprint( rounded, v, str2 );
+                if( testno < 8 )
+                        break;
+/* rounding error measurement */
+                etoasc( fullp, str0, 24 );
+                etoe64( fullp, &ssprec64 );
+                e64toe( &ssprec64, u );
+                sprintf( str2, format, ssprec64 );
+                asctoe( str2, t );
+                cmpprint( u, t );
+                sscanf( str0, fformat, &sprec64 );
+                e64toe( &sprec64, t );
+                cmpscan( fullp, t );
+                if( testno < 8 )
+                        break;
+/* strings rounded to less than maximum precision */
+                e64toasc( &ssprec64, str1, 24 );
+                for( j=SPREC-1; j>0; j-- )              
+                        {
+                        e64toasc( &ssprec64, str3, j );
+                        asctoe( str3, v );
+                        sprintf( tformat, "%s.%dLe", pct, j );
+                        sprintf( str2, tformat, ssprec64 );
+                        asctoe( str2, t );
+                        cmptrunc( v, t );
+                        }
+                break;
+#endif
+#ifdef DEC
+        case 56:
+#endif
+        case 53:
+                etoe53( fullp, &prec53 );
+                e53toe( &prec53, rounded );
+#if CHKINTERNAL
+                e53toasc( &prec53, str1, SPREC );
+                asctoe53( str1, &xprec53 );
+                e53toe( &xprec53, t );
+                chkinternal( rounded, t, str1 );
+#endif
+                sprintf( str2, format, prec53 );
+                sscanf( str2, fformat, &sprec53 );
+                e53toe( &sprec53, u );
+                chkid( rounded, u, str2 );
+                asctoe53( str2, &ssprec53 );
+                e53toe( &ssprec53, v );
+                chkscan( v, u, str2 );
+                chkprint( rounded, v, str2 );
+                if( testno < 8 )
+                        break;
+/* rounding error measurement */
+                etoasc( fullp, str0, 24 );
+                etoe53( fullp, &ssprec53 );
+                e53toe( &ssprec53, u );
+                sprintf( str2, format, ssprec53 );
+                asctoe( str2, t );
+                cmpprint( u, t );
+                sscanf( str0, fformat, &sprec53 );
+                e53toe( &sprec53, t );
+                cmpscan( fullp, t );
+                if( testno < 8 )
+                        break;
+                e53toasc( &ssprec53, str1, 24 );
+                for( j=SPREC-1; j>0; j-- )              
+                        {
+                        e53toasc( &ssprec53, str3, j );
+                        asctoe( str3, v );
+                        sprintf( tformat, "%s.%de", pct, j );
+                        sprintf( str2, tformat, ssprec53 );
+                        asctoe( str2, t );
+                        cmptrunc( v, t );
+                        }
+                break;
+
+        case 24:
+                etoe24( fullp, &prec24 );
+                e24toe( &prec24, rounded );
+#if CHKINTERNAL
+                e24toasc( &prec24, str1, SPREC );
+                asctoe24( str1, &xprec24 );
+                e24toe( &xprec24, t );
+                chkinternal( rounded, t, str1 );
+#endif
+                sprintf( str2, format, prec24 );
+                sscanf( str2, fformat, &sprec24 );
+                e24toe( &sprec24, u );
+                chkid( rounded, u, str2 );
+                asctoe24( str2, &ssprec24 );
+                e24toe( &ssprec24, v );
+                chkscan( v, u, str2 );
+                chkprint( rounded, v, str2 );
+                if( testno < 8 )
+                        break;
+/* rounding error measurement */
+                etoasc( fullp, str0, 24 );
+                etoe24( fullp, &ssprec24 );
+                e24toe( &ssprec24, u );
+                sprintf( str2, format, ssprec24 );
+                asctoe( str2, t );
+                cmpprint( u, t );
+                sscanf( str0, fformat, &sprec24 );
+                e24toe( &sprec24, t );
+                cmpscan( fullp, t );
+/*
+                if( testno < 8 )
+                        break;
+*/
+                e24toasc( &ssprec24, str1, 24 );
+                for( j=SPREC-1; j>0; j-- )              
+                        {
+                        e24toasc( &ssprec24, str3, j );
+                        asctoe( str3, v );
+                        sprintf( tformat, "%s.%de", pct, j );
+                        sprintf( str2, tformat, ssprec24 );
+                        asctoe( str2, t );
+                        cmptrunc( v, t );
+                        }
+                break;
+        }
+}
+
+
+void printerr()
+{
+if( (errscan == 0) && (identerr == 0) && (errprint == 0) )
+        printf( "No errors found.\n" );
+else
+        {
+        printf( "%d binary -> decimal errors found.\n", errprint );
+        printf( "%d decimal -> binary errors found.\n", errscan );
+        }
+errscan = 0;    /* reset for next test */
+identerr = 0;
+errprint = 0;
+errtot = 0;
+}
+
+
+/* Random number generator
+ * in the range M * 10^N, where 1 <= M <= 10^17 - 1
+ * and -27 <= N <= +27.  Test values of M are logarithmically distributed
+ * random integers; test values of N are uniformly distributed random integers.
+ */
+
+static char *fwidth = "1.036163291797320557783096e1"; /* log(sqrt(10^9-1)) */
+static char *dwidth = "1.957197329044938830915E1"; /* log(sqrt(10^17-1)) */
+static char *ldwidth = "2.302585092994045684017491e1"; /* log(sqrt(10^20-1)) */
+
+static char *a13 = "13.0";
+static char *a27 = "27.0";
+static char *a34 = "34.0";
+static char *a10m13 = "1.0e-13";
+static unsigned short LOW[ NE ], WIDTH[NE], e27[NE], e10m13[NE];
+
+
+void mnrand( erand )
+unsigned short erand[];
+{
+unsigned short ea[NE], em[NE], en[NE], ex[NE];
+double x, a;
+
+if( mnrflag )
+        {
+        if( mnrflag == 3 )
+                {
+                asctoe( ldwidth, WIDTH );
+                asctoe( a34, e27 );
+                }
+        if( mnrflag == 2 )
+                {
+                asctoe( dwidth, WIDTH );
+                asctoe( a27, e27 );
+                }
+        if( mnrflag == 1 )
+                {
+                asctoe( fwidth, WIDTH );
+                asctoe( a13, e27 );
+                }
+        asctoe( a10m13, e10m13 );
+        mnrflag = 0;
+        }
+drand( &x );
+e53toe( &x, ex ); /* x = WIDTH *  ( x - 1.0 )  +  LOW; */
+esub( eone, ex, ex );
+emul( WIDTH, ex, ex );
+eexp( ex, ex );   /* x = exp(x); */
+
+drand( &a );
+e53toe( &a, ea );
+emul( ea, ex, ea );  /* a = 1.0e-13 * x * a; */
+emul( e10m13, ea, ea );
+eabs( ea );
+eadd( ea, ex, ex );     /* add fuzz */
+emul( ex, ex, ex );     /* square it, to get range to 10^17 - 1 */
+efloor( ex, em ); /* this is M */
+
+/* Random power of 10 */
+drand( &a );
+e53toe( &a, ex );
+esub( eone, ex, ex ); /* y3 = 54.0 *  ( y3 - 1.0 ) + 0.5; */
+emul( e27, ex, ex );
+eadd( ex, ex, ex );
+eadd( ehalf, ex, ex );
+efloor( ex, ex ); /* y3 = floor( y3 ) - 27.0; */
+esub( e27, ex, en ); /* this is N */
+epow( eten, en, ex );
+emul( ex, em, erand );
+}
+
+/* -ln 2^16382 */
+char *ldemin = "-1.1355137111933024058873097E4";
+char *ldewid =  "2.2710274223866048117746193E4";
+/* -ln 2^1022 */
+char *demin  = "-7.0839641853226410622441123E2";
+char *dewid  =  "1.4167928370645282124488225E3";
+/* -ln 2^125 */
+char *femin  = "-8.6643397569993163677154015E1";
+char *fewid  =  "1.7328679513998632735430803E2";
+
+void etrand( erand )
+unsigned short erand[];
+{
+unsigned short ea[NE], ex[NE];
+double x, a;
+
+if( etrflag )
+        {
+        if( etrflag == 3 )
+                {
+                asctoe( ldemin, LOW );
+                asctoe( ldewid, WIDTH );
+                asctoe( a34, e27 );
+                }
+        if( etrflag == 2 )
+                {
+                asctoe( demin, LOW );
+                asctoe( dewid, WIDTH );
+                asctoe( a27, e27 );
+                }
+        if( etrflag == 1 )
+                {
+                asctoe( femin, LOW );
+                asctoe( fewid, WIDTH );
+                asctoe( a13, e27 );
+                }
+        asctoe( a10m13, e10m13 );
+        etrflag = 0;
+        }
+drand( &x );
+e53toe( &x, ex ); /* x = WIDTH *  ( x - 1.0 )  +  LOW; */
+esub( eone, ex, ex );
+emul( WIDTH, ex, ex );
+eadd( LOW, ex, ex );
+eexp( ex, ex );   /* x = exp(x); */
+
+/* add fuzz
+ */
+drand( &a );
+e53toe( &a, ea );
+emul( ea, ex, ea );  /* a = 1.0e-13 * x * a; */
+emul( e10m13, ea, ea );
+if( ecmp( ex, ezero ) > 0 )
+        eneg( ea );
+eadd( ea, ex, erand );
+}
+
diff --git a/src/regress/lib/libc/cephes/mconf.h b/src/regress/lib/libc/cephes/mconf.h
new file mode 100644
index 0000000000..a92bd3ab64
--- /dev/null
+++ b/src/regress/lib/libc/cephes/mconf.h
@@ -0,0 +1,187 @@
+/*      $OpenBSD: mconf.h,v 1.1 2011/07/02 18:11:01 martynas Exp $      */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                                      mconf.h
+ *
+ *      Common include file for math routines
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * #include "mconf.h"
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * This file contains definitions for error codes that are
+ * passed to the common error handling routine mtherr()
+ * (which see).
+ *
+ * The file also includes a conditional assembly definition
+ * for the type of computer arithmetic (IEEE, DEC, Motorola
+ * IEEE, or UNKnown).
+ * 
+ * For Digital Equipment PDP-11 and VAX computers, certain
+ * IBM systems, and others that use numbers with a 56-bit
+ * significand, the symbol DEC should be defined.  In this
+ * mode, most floating point constants are given as arrays
+ * of octal integers to eliminate decimal to binary conversion
+ * errors that might be introduced by the compiler.
+ *
+ * For little-endian computers, such as IBM PC, that follow the
+ * IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE
+ * Std 754-1985), the symbol IBMPC should be defined.  These
+ * numbers have 53-bit significands.  In this mode, constants
+ * are provided as arrays of hexadecimal 16 bit integers.
+ *
+ * Big-endian IEEE format is denoted MIEEE.  On some RISC
+ * systems such as Sun SPARC, double precision constants
+ * must be stored on 8-byte address boundaries.  Since integer
+ * arrays may be aligned differently, the MIEEE configuration
+ * may fail on such machines.
+ *
+ * To accommodate other types of computer arithmetic, all
+ * constants are also provided in a normal decimal radix
+ * which one can hope are correctly converted to a suitable
+ * format by the available C language compiler.  To invoke
+ * this mode, define the symbol UNK.
+ *
+ * An important difference among these modes is a predefined
+ * set of machine arithmetic constants for each.  The numbers
+ * MACHEP (the machine roundoff error), MAXNUM (largest number
+ * represented), and several other parameters are preset by
+ * the configuration symbol.  Check the file const.c to
+ * ensure that these values are correct for your computer.
+ *
+ * Configurations NANS, INFINITIES, MINUSZERO, and DENORMAL
+ * may fail on many systems.  Verify that they are supposed
+ * to work on your computer.
+ */
+
+#include <sys/types.h>
+#include <sys/endian.h>
+
+/* Constant definitions for math error conditions
+ */
+
+#define DOMAIN          1       /* argument domain error */
+#define SING            2       /* argument singularity */
+#define OVERFLOW        3       /* overflow range error */
+#define UNDERFLOW       4       /* underflow range error */
+#define TLOSS           5       /* total loss of precision */
+#define PLOSS           6       /* partial loss of precision */
+
+#define EDOM            33
+#define ERANGE          34
+
+/* Complex numeral.  */
+typedef struct
+        {
+        double r;
+        double i;
+        } cmplx;
+
+/* Long double complex numeral.  */
+typedef struct
+        {
+        double r;
+        double i;
+        } cmplxl;
+
+/* Type of computer arithmetic */
+
+/* PDP-11, Pro350, VAX:
+ */
+#ifdef  __vax__
+#define DEC 1
+#endif  /* __vax__ */
+
+/* Intel IEEE, low order words come first:
+ */
+/* #define IBMPC 1 */
+
+/* Motorola IEEE, high order words come first
+ * (Sun 680x0 workstation):
+ */
+/* #define MIEEE 1 */
+
+/* UNKnown arithmetic, invokes coefficients given in
+ * normal decimal format.  Beware of range boundary
+ * problems (MACHEP, MAXLOG, etc. in const.c) and
+ * roundoff problems in pow.c:
+ * (Sun SPARCstation)
+ */
+#ifndef __vax__
+#define UNK 1
+#endif  /* !__vax__ */
+
+/* If you define UNK, then be sure to set BIGENDIAN properly. */
+#if     BYTE_ORDER == BIG_ENDIAN
+#define BIGENDIAN 1
+#endif  /* BYTE_ORDER == BIG_ENDIAN */
+
+/* Define this `volatile' if your compiler thinks
+ * that floating point arithmetic obeys the associative
+ * and distributive laws.  It will defeat some optimizations
+ * (but probably not enough of them).
+ *
+ * #define VOLATILE volatile
+ */
+#define VOLATILE
+
+/* For 12-byte long doubles on an i386, pad a 16-bit short 0
+ * to the end of real constants initialized by integer arrays.
+ *
+ * #define XPD 0,
+ *
+ * Otherwise, the type is 10 bytes long and XPD should be
+ * defined blank (e.g., Microsoft C).
+ *
+ * #define XPD
+ */
+#define XPD 0,
+
+/* Define to support tiny denormal numbers, else undefine. */
+#ifndef __vax__
+#define DENORMAL 1
+#endif  /* !__vax__ */
+
+/* Define to ask for infinity support, else undefine. */
+#ifndef __vax__
+#define INFINITIES 1
+#endif  /* !__vax__ */
+
+/* Define to ask for support of numbers that are Not-a-Number,
+   else undefine.  This may automatically define INFINITIES in some files. */
+#ifndef __vax__
+#define NANS 1
+#endif  /* !__vax__ */
+
+/* Define to distinguish between -0.0 and +0.0.  */
+#define MINUSZERO 1
+
+/* Define 1 for ANSI C atan2() function
+   See atan.c and clog.c. */
+#define ANSIC 1
+
+int mtherr();
+
+/* Variable for error reporting.  See mtherr.c.  */
+extern int merror;
diff --git a/src/regress/lib/libc/cephes/mtherr.c b/src/regress/lib/libc/cephes/mtherr.c
new file mode 100644
index 0000000000..9a47a198bd
--- /dev/null
+++ b/src/regress/lib/libc/cephes/mtherr.c
@@ -0,0 +1,114 @@
+/*      $OpenBSD: mtherr.c,v 1.1 2011/07/02 18:11:01 martynas Exp $     */
+
+/*
+ * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*                                                      mtherr.c
+ *
+ *      Library common error handling routine
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * char *fctnam;
+ * int code;
+ * int mtherr();
+ *
+ * mtherr( fctnam, code );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * This routine may be called to report one of the following
+ * error conditions (in the include file mconf.h).
+ *  
+ *   Mnemonic        Value          Significance
+ *
+ *    DOMAIN            1       argument domain error
+ *    SING              2       function singularity
+ *    OVERFLOW          3       overflow range error
+ *    UNDERFLOW         4       underflow range error
+ *    TLOSS             5       total loss of precision
+ *    PLOSS             6       partial loss of precision
+ *    EDOM             33       Unix domain error code
+ *    ERANGE           34       Unix range error code
+ *
+ * The default version of the file prints the function name,
+ * passed to it by the pointer fctnam, followed by the
+ * error condition.  The display is directed to the standard
+ * output device.  The routine then returns to the calling
+ * program.  Users may wish to modify the program to abort by
+ * calling exit() under severe error conditions such as domain
+ * errors.
+ *
+ * Since all error conditions pass control to this function,
+ * the display may be easily changed, eliminated, or directed
+ * to an error logging device.
+ *
+ * SEE ALSO:
+ *
+ * mconf.h
+ *
+ */
+
+#include <stdio.h>
+#include "mconf.h"
+
+int merror = 0;
+
+/* Notice: the order of appearance of the following
+ * messages is bound to the error codes defined
+ * in mconf.h.
+ */
+static char *ermsg[7] = {
+"unknown",      /* error code 0 */
+"domain",       /* error code 1 */
+"singularity",  /* et seq.      */
+"overflow",
+"underflow",
+"total loss of precision",
+"partial loss of precision"
+};
+
+
+int mtherr( name, code )
+char *name;
+int code;
+{
+
+/* Display string passed by calling program,
+ * which is supposed to be the name of the
+ * function in which the error occurred:
+ */
+printf( "\n%s ", name );
+
+/* Set global error message word */
+merror = code;
+
+/* Display error message defined
+ * by the code argument.
+ */
+if( (code <= 0) || (code >= 7) )
+        code = 0;
+printf( "%s error\n", ermsg[code] );
+
+/* Return to calling
+ * program
+ */
+return( 0 );
+}
diff --git a/src/regress/lib/libc/cxa-atexit/Makefile b/src/regress/lib/libc/cxa-atexit/Makefile
new file mode 100644
index 0000000000..5061ca04ac
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/Makefile
@@ -0,0 +1,12 @@
+# $OpenBSD: Makefile,v 1.2 2010/05/10 18:20:31 drahn Exp $
+
+.include <bsd.own.mk>
+
+
+.if ${COMPILER_VERSION:L} == "gcc3" || ${COMPILER_VERSION:L} == "gcc4" 
+SUBDIR+= libgd1 libgd2 test1
+.endif
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/cxa-atexit/libgd1/Makefile b/src/regress/lib/libc/cxa-atexit/libgd1/Makefile
new file mode 100644
index 0000000000..958b726d28
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd1/Makefile
@@ -0,0 +1,9 @@
+# $OpenBSD: Makefile,v 1.1 2007/09/03 14:42:44 millert Exp $
+
+LIB=gd1
+SRCS= gd1.C
+NOPROFILE=yes
+
+regress: all
+
+.include <bsd.lib.mk>
diff --git a/src/regress/lib/libc/cxa-atexit/libgd1/gd1.C b/src/regress/lib/libc/cxa-atexit/libgd1/gd1.C
new file mode 100644
index 0000000000..b3ecd56d91
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd1/gd1.C
@@ -0,0 +1,32 @@
+/*      $OpenBSD: gd1.C,v 1.1 2007/09/03 14:42:44 millert Exp $ */
+
+/*
+ * Copyright (c) 2007 Kurt Miller <kurt@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+
+extern int check1;
+
+struct global_destructor_test_obj1 {
+        inline ~global_destructor_test_obj1() {
+                check1 = 0;
+        }
+};
+
+extern "C" void gd_test1()
+{
+        static global_destructor_test_obj1 gdt;
+}
diff --git a/src/regress/lib/libc/cxa-atexit/libgd1/shlib_version b/src/regress/lib/libc/cxa-atexit/libgd1/shlib_version
new file mode 100644
index 0000000000..97c9f92d6b
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd1/shlib_version
@@ -0,0 +1,2 @@
+major=0
+minor=0
diff --git a/src/regress/lib/libc/cxa-atexit/libgd2/Makefile b/src/regress/lib/libc/cxa-atexit/libgd2/Makefile
new file mode 100644
index 0000000000..7ca21d8bd2
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd2/Makefile
@@ -0,0 +1,9 @@
+# $OpenBSD: Makefile,v 1.1 2007/09/03 14:42:44 millert Exp $
+
+LIB=gd2
+SRCS= gd2.C
+NOPROFILE=yes
+
+regress: all
+
+.include <bsd.lib.mk>
diff --git a/src/regress/lib/libc/cxa-atexit/libgd2/gd2.C b/src/regress/lib/libc/cxa-atexit/libgd2/gd2.C
new file mode 100644
index 0000000000..69e7ffb220
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd2/gd2.C
@@ -0,0 +1,32 @@
+/*      $OpenBSD: gd2.C,v 1.1 2007/09/03 14:42:44 millert Exp $ */
+
+/*
+ * Copyright (c) 2007 Kurt Miller <kurt@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+
+extern int check2;
+
+struct global_destructor_test_obj2 {
+        inline ~global_destructor_test_obj2() {
+                check2 = 0;
+        }
+};
+
+extern "C" void gd_test2()
+{
+        static global_destructor_test_obj2 gdt;
+}
diff --git a/src/regress/lib/libc/cxa-atexit/libgd2/shlib_version b/src/regress/lib/libc/cxa-atexit/libgd2/shlib_version
new file mode 100644
index 0000000000..97c9f92d6b
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd2/shlib_version
@@ -0,0 +1,2 @@
+major=0
+minor=0
diff --git a/src/regress/lib/libc/cxa-atexit/test1/Makefile b/src/regress/lib/libc/cxa-atexit/test1/Makefile
new file mode 100644
index 0000000000..533392d144
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/test1/Makefile
@@ -0,0 +1,29 @@
+# $OpenBSD: Makefile,v 1.1 2007/09/03 14:42:44 millert Exp $
+
+.include <bsd.obj.mk>
+
+GD1_DIR=${.CURDIR}/../libgd1
+GD1_OBJDIR!=    if [ -d $(GD1_DIR)/${__objdir} ]; then \
+                        echo "$(GD1_DIR)/${__objdir}"; \
+                else \
+                        echo "$(GD1_DIR)"; \
+                fi
+
+GD2_DIR=${.CURDIR}/../libgd2
+GD2_OBJDIR!=    if [ -d $(GD2_DIR)/${__objdir} ]; then \
+                        echo "$(GD2_DIR)/${__objdir}"; \
+                else \
+                        echo "$(GD2_DIR)"; \
+                fi
+
+PROG=           test1
+
+SRCS=           test1.C
+
+CFLAGS+=        -DLIBGD1="\"$(GD1_OBJDIR)/libgd1.so\""
+CFLAGS+=        -DLIBGD2="\"$(GD2_OBJDIR)/libgd2.so\""
+LDFLAGS+=       -Wl,-E
+
+NOMAN=
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/cxa-atexit/test1/test1.C b/src/regress/lib/libc/cxa-atexit/test1/test1.C
new file mode 100644
index 0000000000..75fb967a90
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/test1/test1.C
@@ -0,0 +1,63 @@
+/*      $OpenBSD: test1.C,v 1.1 2007/09/03 14:42:44 millert Exp $       */
+
+/*
+ * Copyright (c) 2007 Kurt Miller <kurt@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <dlfcn.h>
+#include <err.h>
+#include <stdio.h>
+
+int check1, check2;
+
+int
+main()
+{
+        void *libgd1, *libgd2;
+        void (*gd_test)();
+        int i;
+
+        for (i=0; i < 50; i++) {
+                check1 = check2 = 1;
+
+                libgd1 = dlopen(LIBGD1, RTLD_LAZY);
+                if (libgd1 == NULL)
+                        errx(1, "dlopen(%s, RTLD_LAZY) FAILED\n", LIBGD1);
+
+                gd_test = (void (*)())dlsym(libgd1, "gd_test1");
+                if (gd_test == NULL)
+                        errx(1, "dlsym(libgd1, \"gd_test1\") FAILED\n");
+
+                (*gd_test)();
+
+                libgd2 = dlopen(LIBGD2, RTLD_LAZY);
+                if (libgd2 == NULL)
+                        errx(1, "dlopen(%s, RTLD_LAZY) FAILED\n", LIBGD2);
+
+                gd_test = (void (*)())dlsym(libgd2, "gd_test2");
+                if (gd_test == NULL)
+                        errx(1, "dlsym(libgd2, \"gd_test2\") FAILED\n");
+
+                (*gd_test)();
+
+                dlclose(libgd1);
+                dlclose(libgd2);
+
+                if (check1 || check2)
+                        errx(1, "global destructors not called\n");
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/db/Makefile b/src/regress/lib/libc/db/Makefile
index 5bf343bf64..7d2882594d 100644
--- a/src/regress/lib/libc/db/Makefile
+++ b/src/regress/lib/libc/db/Makefile
@@ -1,17 +1,22 @@
-#       $NetBSD: Makefile,v 1.10 1995/04/20 22:39:11 cgd Exp $
-#       @(#)Makefile    8.1 (Berkeley) 6/4/93
+#       $OpenBSD: Makefile,v 1.10 2002/09/02 20:01:43 avsm Exp $
+#       $NetBSD: Makefile,v 1.11 1995/12/12 01:54:15 cgd Exp $
 
 PROG=   dbtest
 
 # add -DSTATISTICS to CFLAGS to get usage statistics.  Note that
 # for this to work, libc must be compiled with -DSTATISTICS as well
-CFLAGS= -g -D__DBINTERFACE_PRIVATE -DDEBUG
-NOMAN=  noman
-CLEANFILES+= t1 t2 t3
+CFLAGS+= -g -D__DBINTERFACE_PRIVATE -DDEBUG
+CLEANFILES+= t1 t2 t3 log
 
-install:
+DBTARGETS=1 2 3 4 5 6 7 8 9 10 11 12 13 20
 
-regress:
-        sh ${.CURDIR}/run.test
+.for DT in ${DBTARGETS}
+db-${DT}: ${PROG}
+        sh ${.CURDIR}/run.test ${DT}
+REGRESS_TARGETS+=db-${DT}
+.PHONY: db-${DT}
+.endfor
 
-.include <bsd.prog.mk>
+REGRESS_SLOW_TARGETS+=db-3 db-12 db-20
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/db/README b/src/regress/lib/libc/db/README
index 3b290b09d8..23a1b77221 100644
--- a/src/regress/lib/libc/db/README
+++ b/src/regress/lib/libc/db/README
@@ -1,5 +1,6 @@
-#       $NetBSD: README,v 1.4 1995/04/20 22:39:18 cgd Exp $
-#       @(#)README      8.4 (Berkeley) 6/20/94
+#       $OpenBSD: README,v 1.3 2001/01/29 02:05:40 niklas Exp $
+#       $NetBSD: README,v 1.5 1996/05/03 21:54:19 cgd Exp $
+#       @(#)README      8.8 (Berkeley) 7/31/94
 
 To run the tests, enter "make regress".
 
@@ -9,8 +10,11 @@ the test runs, and even larger files (the database files) are created in
 variable TMPDIR to a directory where the files can be built.
 
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-The script file consists of lines with a initial character which is
-the "command" for that line.  Legal characters are as follows:
+The script file consists of lines with an initial character which is
+the command for that line, or an initial character indicating a key
+or data entry for a previous command.
+
+Legal command characters are as follows:
 
 c: compare a record
         + must be followed by [kK][dD]; the data value in the database
@@ -19,17 +23,24 @@ c: compare a record
 e: echo a string
         + writes out the rest of the line into the output file; if the
           last character is not a carriage-return, a newline is appended.
+f: set the flags for the next command
+        + no value zero's the flags
 g: do a get command
         + must be followed by [kK]
         + writes out the retrieved data DBT.
+o [r]: dump [reverse]
+        + dump the database out, if 'r' is set, in reverse order.
 p: do a put command
         + must be followed by [kK][dD]
 r: do a del command
-        + must be followed by [kK]
+        + must be followed by [kK] unless R_CURSOR flag set.
+S: sync the database
 s: do a seq command
+        + must be followed by [kK] if R_CURSOR flag set.
         + writes out the retrieved data DBT.
-f: set the flags for the next command
-        + no value zero's the flags
+
+Legal key/data characters are as follows:
+
 D [file]: data file
         + set the current data value to the contents of the file
 d [data]:
@@ -38,17 +49,21 @@ K [file]: key file
         + set the current key value to the contents of the file
 k [data]:
         + set the current key value to the contents of the line.
-o [r]: dump [reverse]
-        + dump the database out, if 'r' is set, in reverse order.
+
+Blank lines, lines with leading white space, and lines with leading
+hash marks (#) are ignored.
 
 Options to dbtest are as follows:
 
+        -d: Set the DB_LOCK flag.
         -f: Use the file argument as the database file.
         -i: Use the rest of the argument to set elements in the info
             structure.  If the type is btree, then "-i cachesize=10240"
             will set BTREEINFO.cachesize to 10240.
         -o: The rest of the argument is the output file instead of
             using stdout.
+        -s: Don't delete the database file before opening it, i.e.
+            use the database file from a previous run.
 
-Dbtest requires two arguments, the type of access "hash", "recno" or
-"btree", and the script name.
+Dbtest requires two arguments, the type of access "hash", "recno"
+or "btree", and the script name or "-" to indicate stdin.
diff --git a/src/regress/lib/libc/db/dbtest.c b/src/regress/lib/libc/db/dbtest.c
index 1fcf09af97..c28ec0db5e 100644
--- a/src/regress/lib/libc/db/dbtest.c
+++ b/src/regress/lib/libc/db/dbtest.c
@@ -1,7 +1,8 @@
-/*      $NetBSD: dbtest.c,v 1.7 1995/04/20 22:39:22 cgd Exp $   */
+/*      $OpenBSD: dbtest.c,v 1.12 2009/10/27 23:59:32 deraadt Exp $     */
+/*      $NetBSD: dbtest.c,v 1.8 1996/05/03 21:57:48 cgd Exp $   */
 
 /*-
- * Copyright (c) 1992, 1993
+ * Copyright (c) 1992, 1993, 1994
  *      The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -12,11 +13,7 @@
  * 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.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
@@ -33,20 +30,6 @@
  * SUCH DAMAGE.
  */
 
-#ifndef lint
-static char copyright[] =
-"@(#) Copyright (c) 1992, 1993\n\
-        The Regents of the University of California.  All rights reserved.\n";
-#endif /* not lint */
-
-#ifndef lint
-#if 0
-static char sccsid[] = "@(#)dbtest.c    8.8 (Berkeley) 2/21/94";
-#else
-static char rcsid[] = "$NetBSD: dbtest.c,v 1.7 1995/04/20 22:39:22 cgd Exp $";
-#endif
-#endif /* not lint */
-
 #include <sys/param.h>
 #include <sys/stat.h>
 
@@ -57,39 +40,41 @@ static char rcsid[] = "$NetBSD: dbtest.c,v 1.7 1995/04/20 22:39:22 cgd Exp $";
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdarg.h>
 #include <unistd.h>
 
 #include <db.h>
 
 enum S { COMMAND, COMPARE, GET, PUT, REMOVE, SEQ, SEQFLAG, KEY, DATA };
 
-void     compare __P((DBT *, DBT *));
-DBTYPE   dbtype __P((char *));
-void     dump __P((DB *, int));
-void     err __P((const char *, ...));
-void     get __P((DB *, DBT *));
-void     getdata __P((DB *, DBT *, DBT *));
-void     put __P((DB *, DBT *, DBT *));
-void     rem __P((DB *, DBT *));
-void    *rfile __P((char *, size_t *));
-void     seq __P((DB *, DBT *));
-u_int    setflags __P((char *));
-void    *setinfo __P((DBTYPE, char *));
-void     usage __P((void));
-void    *xmalloc __P((char *, size_t));
-
-DBTYPE type;
-void *infop;
-u_long lineno;
-u_int flags;
-int ofd = STDOUT_FILENO;
+void     compare(DBT *, DBT *);
+DBTYPE   dbtype(char *);
+void     dump(DB *, int);
+void     dberr(const char *, ...);
+void     get(DB *, DBT *);
+void     getdata(DB *, DBT *, DBT *);
+void     put(DB *, DBT *, DBT *);
+void     rem(DB *, DBT *);
+char    *sflags(int);
+void     synk(DB *);
+void    *rfile(char *, size_t *);
+void     seq(DB *, DBT *);
+u_int    setflags(char *);
+void    *setinfo(DBTYPE, char *);
+void     usage(void);
+void    *xmalloc(char *, size_t);
+
+DBTYPE type;                            /* Database type. */
+void *infop;                            /* Iflags. */
+u_long lineno;                          /* Current line in test script. */
+u_int flags;                            /* Current DB flags. */
+int ofd = STDOUT_FILENO;                /* Standard output fd. */
 
 DB *XXdbp;                              /* Global for gdb. */
+int XXlineno;                           /* Fast breakpoint for gdb. */
 
 int
-main(argc, argv)
-        int argc;
-        char *argv[];
+main(int argc, char *argv[])
 {
         extern int optind;
         extern char *optarg;
@@ -97,14 +82,15 @@ main(argc, argv)
         DB *dbp;
         DBT data, key, keydata;
         size_t len;
-        int ch, oflags;
-        char *fname, *infoarg, *p, buf[8 * 1024];
+        int ch, oflags, sflag;
+        char *fname, *infoarg, *p, *t, buf[8 * 1024];
 
         infoarg = NULL;
         fname = NULL;
         oflags = O_CREAT | O_RDWR;
-        while ((ch = getopt(argc, argv, "f:i:lo:")) != EOF)
-                switch(ch) {
+        sflag = 0;
+        while ((ch = getopt(argc, argv, "f:i:lo:s")) != -1)
+                switch (ch) {
                 case 'f':
                         fname = optarg;
                         break;
@@ -117,7 +103,10 @@ main(argc, argv)
                 case 'o':
                         if ((ofd = open(optarg,
                             O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
-                                err("%s: %s", optarg, strerror(errno));
+                                dberr("%s: %s", optarg, strerror(errno));
+                        break;
+                case 's':
+                        sflag = 1;
                         break;
                 case '?':
                 default:
@@ -133,8 +122,8 @@ main(argc, argv)
         type = dbtype(*argv++);
 
         /* Open the descriptor file. */
-        if (freopen(*argv, "r", stdin) == NULL)
-                err("%s: %s", *argv, strerror(errno));
+        if (strcmp(*argv, "-") && freopen(*argv, "r", stdin) == NULL)
+            dberr("%s: %s", *argv, strerror(errno));
 
         /* Set up the db structure as necessary. */
         if (infoarg == NULL)
@@ -145,61 +134,93 @@ main(argc, argv)
                         if (*p != '\0')
                                 infop = setinfo(type, p);
 
-        /* Open the DB. */
+        /*
+         * Open the DB.  Delete any preexisting copy, you almost never
+         * want it around, and it often screws up tests.
+         */
         if (fname == NULL) {
                 p = getenv("TMPDIR");
                 if (p == NULL)
                         p = "/var/tmp";
-                (void)sprintf(buf, "%s/__dbtest", p);
+                (void)snprintf(buf, sizeof buf, "%s/__dbtest", p);
                 fname = buf;
                 (void)unlink(buf);
-        }
+        } else  if (!sflag)
+                (void)unlink(fname);
+
         if ((dbp = dbopen(fname,
             oflags, S_IRUSR | S_IWUSR, type, infop)) == NULL)
-                err("dbopen: %s", strerror(errno));
+                dberr("dbopen: %s", strerror(errno));
         XXdbp = dbp;
 
         state = COMMAND;
         for (lineno = 1;
             (p = fgets(buf, sizeof(buf), stdin)) != NULL; ++lineno) {
-                len = strlen(buf);
-                switch(*p) {
+                /* Delete the newline, displaying the key/data is easier. */
+                if (ofd == STDOUT_FILENO && (t = strchr(p, '\n')) != NULL)
+                        *t = '\0';
+                if ((len = strlen(buf)) == 0 || isspace(*p) || *p == '#')
+                        continue;
+
+                /* Convenient gdb break point. */
+                if (XXlineno == lineno)
+                        XXlineno = 1;
+                switch (*p) {
                 case 'c':                       /* compare */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         state = KEY;
                         command = COMPARE;
                         break;
                 case 'e':                       /* echo */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         /* Don't display the newline, if CR at EOL. */
                         if (p[len - 2] == '\r')
                                 --len;
-                        if (write(ofd, p + 1, len - 1) != len - 1)
-                                err("write: %s", strerror(errno));
+                        if (write(ofd, p + 1, len - 1) != len - 1 ||
+                            write(ofd, "\n", 1) != 1)
+                                dberr("write: %s", strerror(errno));
                         break;
                 case 'g':                       /* get */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         state = KEY;
                         command = GET;
                         break;
                 case 'p':                       /* put */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         state = KEY;
                         command = PUT;
                         break;
                 case 'r':                       /* remove */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
-                        state = KEY;
-                        command = REMOVE;
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        if (flags == R_CURSOR) {
+                                rem(dbp, &key);
+                                state = COMMAND;
+                        } else {
+                                state = KEY;
+                                command = REMOVE;
+                        }
+                        break;
+                case 'S':                       /* sync */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        synk(dbp);
+                        state = COMMAND;
                         break;
                 case 's':                       /* seq */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         if (flags == R_CURSOR) {
                                 state = KEY;
                                 command = SEQ;
@@ -211,15 +232,15 @@ main(argc, argv)
                         break;
                 case 'D':                       /* data file */
                         if (state != DATA)
-                                err("line %lu: not expecting data", lineno);
+                                dberr("line %lu: not expecting data", lineno);
                         data.data = rfile(p + 1, &data.size);
                         goto ldata;
                 case 'd':                       /* data */
                         if (state != DATA)
-                                err("line %lu: not expecting data", lineno);
+                                dberr("line %lu: not expecting data", lineno);
                         data.data = xmalloc(p + 1, len - 1);
                         data.size = len - 1;
-ldata:                  switch(command) {
+ldata:                  switch (command) {
                         case COMPARE:
                                 compare(&keydata, &data);
                                 break;
@@ -227,7 +248,7 @@ ldata:			switch(command) {
                                 put(dbp, &key, &data);
                                 break;
                         default:
-                                err("line %lu: command doesn't take data",
+                                dberr("line %lu: command doesn't take data",
                                     lineno);
                         }
                         if (type != DB_RECNO)
@@ -237,15 +258,15 @@ ldata:			switch(command) {
                         break;
                 case 'K':                       /* key file */
                         if (state != KEY)
-                                err("line %lu: not expecting a key", lineno);
+                                dberr("line %lu: not expecting a key", lineno);
                         if (type == DB_RECNO)
-                                err("line %lu: 'K' not available for recno",
+                                dberr("line %lu: 'K' not available for recno",
                                     lineno);
                         key.data = rfile(p + 1, &key.size);
                         goto lkey;
                 case 'k':                       /* key */
                         if (state != KEY)
-                                err("line %lu: not expecting a key", lineno);
+                                dberr("line %lu: not expecting a key", lineno);
                         if (type == DB_RECNO) {
                                 static recno_t recno;
                                 recno = atoi(p + 1);
@@ -255,7 +276,7 @@ ldata:			switch(command) {
                                 key.data = xmalloc(p + 1, len - 1);
                                 key.size = len - 1;
                         }
-lkey:                   switch(command) {
+lkey:                   switch (command) {
                         case COMPARE:
                                 getdata(dbp, &key, &keydata);
                                 state = DATA;
@@ -271,18 +292,18 @@ lkey:			switch(command) {
                                 break;
                         case REMOVE:
                                 rem(dbp, &key);
-                                if (type != DB_RECNO)
+                                if ((type != DB_RECNO) && (flags != R_CURSOR))
                                         free(key.data);
                                 state = COMMAND;
                                 break;
                         case SEQ:
                                 seq(dbp, &key);
-                                if (type != DB_RECNO)
+                                if ((type != DB_RECNO) && (flags != R_CURSOR))
                                         free(key.data);
                                 state = COMMAND;
                                 break;
                         default:
-                                err("line %lu: command doesn't take a key",
+                                dberr("line %lu: command doesn't take a key",
                                     lineno);
                         }
                         break;
@@ -290,22 +311,25 @@ lkey:			switch(command) {
                         dump(dbp, p[1] == 'r');
                         break;
                 default:
-                        err("line %lu: %s: unknown command character",
-                            p, lineno);
+                        dberr("line %lu: %s: unknown command character",
+                            lineno, p);
                 }
         }
 #ifdef STATISTICS
-        if (type == DB_BTREE)
+        /*
+         * -l must be used (DB_LOCK must be set) for this to be
+         * used, otherwise a page will be locked and it will fail.
+         */
+        if (type == DB_BTREE && oflags & DB_LOCK)
                 __bt_stat(dbp);
 #endif
         if (dbp->close(dbp))
-                err("db->close: %s", strerror(errno));
+                dberr("db->close: %s", strerror(errno));
         (void)close(ofd);
         exit(0);
 }
 
 #define NOOVERWRITE     "put failed, would overwrite key\n"
-#define NOSUCHKEY       "get failed, no such key\n"
 
 void
 compare(db1, db2)
@@ -334,17 +358,23 @@ get(dbp, kp)
 {
         DBT data;
 
-        switch(dbp->get(dbp, kp, &data, flags)) {
+        switch (dbp->get(dbp, kp, &data, flags)) {
         case 0:
                 (void)write(ofd, data.data, data.size);
+                if (ofd == STDOUT_FILENO)
+                        (void)write(ofd, "\n", 1);
                 break;
         case -1:
-                err("line %lu: get: %s", lineno, strerror(errno));
+                dberr("line %lu: get: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
-                (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
-                (void)fprintf(stderr, "%d: %.*s: %s\n", 
-                    lineno, kp->size, kp->data, NOSUCHKEY);
+#define NOSUCHKEY       "get failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else
+                        (void)fprintf(stderr, "%d: %.*s: %s",
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+#undef  NOSUCHKEY
                 break;
         }
 }
@@ -354,14 +384,14 @@ getdata(dbp, kp, dp)
         DB *dbp;
         DBT *kp, *dp;
 {
-        switch(dbp->get(dbp, kp, dp, flags)) {
+        switch (dbp->get(dbp, kp, dp, flags)) {
         case 0:
                 return;
         case -1:
-                err("line %lu: getdata: %s", lineno, strerror(errno));
+                dberr("line %lu: getdata: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
-                err("line %lu: get failed, no such key", lineno);
+                dberr("line %lu: getdata failed, no such key", lineno);
                 /* NOTREACHED */
         }
 }
@@ -371,11 +401,11 @@ put(dbp, kp, dp)
         DB *dbp;
         DBT *kp, *dp;
 {
-        switch(dbp->put(dbp, kp, dp, flags)) {
+        switch (dbp->put(dbp, kp, dp, flags)) {
         case 0:
                 break;
         case -1:
-                err("line %lu: put: %s", lineno, strerror(errno));
+                dberr("line %lu: put: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
                 (void)write(ofd, NOOVERWRITE, sizeof(NOOVERWRITE) - 1);
@@ -388,15 +418,37 @@ rem(dbp, kp)
         DB *dbp;
         DBT *kp;
 {
-        switch(dbp->del(dbp, kp, flags)) {
+        switch (dbp->del(dbp, kp, flags)) {
         case 0:
                 break;
         case -1:
-                err("line %lu: get: %s", lineno, strerror(errno));
+                dberr("line %lu: rem: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
-                (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+#define NOSUCHKEY       "rem failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else if (flags != R_CURSOR)
+                        (void)fprintf(stderr, "%d: %.*s: %s", 
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+                else
+                        (void)fprintf(stderr,
+                            "%d: rem of cursor failed\n", lineno);
+#undef  NOSUCHKEY
+                break;
+        }
+}
+
+void
+synk(dbp)
+        DB *dbp;
+{
+        switch (dbp->sync(dbp, flags)) {
+        case 0:
                 break;
+        case -1:
+                dberr("line %lu: synk: %s", lineno, strerror(errno));
+                /* NOTREACHED */
         }
 }
 
@@ -407,15 +459,26 @@ seq(dbp, kp)
 {
         DBT data;
 
-        switch(dbp->seq(dbp, kp, &data, flags)) {
+        switch (dbp->seq(dbp, kp, &data, flags)) {
         case 0:
                 (void)write(ofd, data.data, data.size);
+                if (ofd == STDOUT_FILENO)
+                        (void)write(ofd, "\n", 1);
                 break;
         case -1:
-                err("line %lu: seq: %s", lineno, strerror(errno));
+                dberr("line %lu: seq: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
-                (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+#define NOSUCHKEY       "seq failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else if (flags == R_CURSOR)
+                        (void)fprintf(stderr, "%d: %.*s: %s", 
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+                else
+                        (void)fprintf(stderr,
+                            "%d: seq (%s) failed\n", lineno, sflags(flags));
+#undef  NOSUCHKEY
                 break;
         }
 }
@@ -436,14 +499,16 @@ dump(dbp, rev)
                 nflags = R_NEXT;
         }
         for (;; flags = nflags)
-                switch(dbp->seq(dbp, &key, &data, flags)) {
+                switch (dbp->seq(dbp, &key, &data, flags)) {
                 case 0:
                         (void)write(ofd, data.data, data.size);
+                        if (ofd == STDOUT_FILENO)
+                                (void)write(ofd, "\n", 1);
                         break;
                 case 1:
                         goto done;
                 case -1:
-                        err("line %lu: (dump) seq: %s",
+                        dberr("line %lu: (dump) seq: %s",
                             lineno, strerror(errno));
                         /* NOTREACHED */
                 }
@@ -454,34 +519,45 @@ u_int
 setflags(s)
         char *s;
 {
-        char *p, *index();
+        char *p;
 
         for (; isspace(*s); ++s);
-        if (*s == '\n')
+        if (*s == '\n' || *s == '\0')
                 return (0);
-        if ((p = index(s, '\n')) != NULL)
+        if ((p = strchr(s, '\n')) != NULL)
                 *p = '\0';
-        if (!strcmp(s, "R_CURSOR"))
-                return (R_CURSOR);
-        if (!strcmp(s, "R_FIRST"))
-                return (R_FIRST);
-        if (!strcmp(s, "R_IAFTER"))
-                return (R_IAFTER);
-        if (!strcmp(s, "R_IBEFORE"))
-                return (R_IBEFORE);
-        if (!strcmp(s, "R_LAST"))
-                return (R_LAST);
-        if (!strcmp(s, "R_NEXT"))
-                return (R_NEXT);
-        if (!strcmp(s, "R_NOOVERWRITE"))
-                return (R_NOOVERWRITE);
-        if (!strcmp(s, "R_PREV"))
-                return (R_PREV);
-        if (!strcmp(s, "R_SETCURSOR"))
-                return (R_SETCURSOR);
-        err("line %lu: %s: unknown flag", lineno, s);
+        if (!strcmp(s, "R_CURSOR"))             return (R_CURSOR);
+        if (!strcmp(s, "R_FIRST"))              return (R_FIRST);
+        if (!strcmp(s, "R_IAFTER"))             return (R_IAFTER);
+        if (!strcmp(s, "R_IBEFORE"))            return (R_IBEFORE);
+        if (!strcmp(s, "R_LAST"))               return (R_LAST);
+        if (!strcmp(s, "R_NEXT"))               return (R_NEXT);
+        if (!strcmp(s, "R_NOOVERWRITE"))        return (R_NOOVERWRITE);
+        if (!strcmp(s, "R_PREV"))               return (R_PREV);
+        if (!strcmp(s, "R_SETCURSOR"))          return (R_SETCURSOR);
+
+        dberr("line %lu: %s: unknown flag", lineno, s);
         /* NOTREACHED */
 }
+
+char *
+sflags(flags)
+        int flags;
+{
+        switch (flags) {
+        case R_CURSOR:          return ("R_CURSOR");
+        case R_FIRST:           return ("R_FIRST");
+        case R_IAFTER:          return ("R_IAFTER");
+        case R_IBEFORE:         return ("R_IBEFORE");
+        case R_LAST:            return ("R_LAST");
+        case R_NEXT:            return ("R_NEXT");
+        case R_NOOVERWRITE:     return ("R_NOOVERWRITE");
+        case R_PREV:            return ("R_PREV");
+        case R_SETCURSOR:       return ("R_SETCURSOR");
+        }
+
+        return ("UNKNOWN!");
+}
         
 DBTYPE
 dbtype(s)
@@ -493,7 +569,7 @@ dbtype(s)
                 return (DB_HASH);
         if (!strcmp(s, "recno"))
                 return (DB_RECNO);
-        err("%s: unknown type (use btree, hash or recno)", s);
+        dberr("%s: unknown type (use btree, hash or recno)", s);
         /* NOTREACHED */
 }
 
@@ -505,15 +581,15 @@ setinfo(type, s)
         static BTREEINFO ib;
         static HASHINFO ih;
         static RECNOINFO rh;
-        char *eq, *index();
+        char *eq;
 
-        if ((eq = index(s, '=')) == NULL)
-                err("%s: illegal structure set statement", s);
+        if ((eq = strchr(s, '=')) == NULL)
+                dberr("%s: illegal structure set statement", s);
         *eq++ = '\0';
         if (!isdigit(*eq))
-                err("%s: structure set statement must be a number", s);
+                dberr("%s: structure set statement must be a number", s);
                 
-        switch(type) {
+        switch (type) {
         case DB_BTREE:
                 if (!strcmp("flags", s)) {
                         ib.flags = atoi(eq);
@@ -589,7 +665,7 @@ setinfo(type, s)
                 }
                 break;
         }
-        err("%s: unknown structure value", s);
+        dberr("%s: unknown structure value", s);
         /* NOTREACHED */
 }
 
@@ -601,20 +677,20 @@ rfile(name, lenp)
         struct stat sb;
         void *p;
         int fd;
-        char *np, *index();
+        char *np;
 
         for (; isspace(*name); ++name);
-        if ((np = index(name, '\n')) != NULL)
+        if ((np = strchr(name, '\n')) != NULL)
                 *np = '\0';
         if ((fd = open(name, O_RDONLY, 0)) < 0 ||
             fstat(fd, &sb))
-                err("%s: %s\n", name, strerror(errno));
+                dberr("%s: %s\n", name, strerror(errno));
 #ifdef NOT_PORTABLE
         if (sb.st_size > (off_t)SIZE_T_MAX)
-                err("%s: %s\n", name, strerror(E2BIG));
+                dberr("%s: %s\n", name, strerror(E2BIG));
 #endif
         if ((p = (void *)malloc((u_int)sb.st_size)) == NULL)
-                err("%s", strerror(errno));
+                dberr("%s", strerror(errno));
         (void)read(fd, p, (int)sb.st_size);
         *lenp = sb.st_size;
         (void)close(fd);
@@ -629,7 +705,7 @@ xmalloc(text, len)
         void *p;
 
         if ((p = (void *)malloc(len)) == NULL)
-                err("%s", strerror(errno));
+                dberr("%s", strerror(errno));
         memmove(p, text, len);
         return (p);
 }
@@ -642,27 +718,12 @@ usage()
         exit(1);
 }
 
-#if __STDC__
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
-
 void
-#if __STDC__
-err(const char *fmt, ...)
-#else
-err(fmt, va_alist)
-        char *fmt;
-        va_dcl
-#endif
+dberr(const char *fmt, ...)
 {
         va_list ap;
-#if __STDC__
+
         va_start(ap, fmt);
-#else
-        va_start(ap);
-#endif
         (void)fprintf(stderr, "dbtest: ");
         (void)vfprintf(stderr, fmt, ap);
         va_end(ap);
diff --git a/src/regress/lib/libc/db/run.test b/src/regress/lib/libc/db/run.test
index 4073310a31..0d6837e360 100644
--- a/src/regress/lib/libc/db/run.test
+++ b/src/regress/lib/libc/db/run.test
@@ -1,19 +1,28 @@
 #!/bin/sh -
-#       $NetBSD: run.test,v 1.7 1995/04/20 22:39:27 cgd Exp $
 #
-#       @(#)run.test    8.8 (Berkeley) 6/16/94
+#       $OpenBSD: run.test,v 1.3 2001/01/29 02:05:41 niklas Exp $
+#       $NetBSD: run.test,v 1.8 1996/05/03 21:57:51 cgd Exp $
+#       @(#)run.test    8.10 (Berkeley) 7/26/94
 #
 
 # db regression tests
 main()
 {
 
-DICT=/usr/share/dict/web2
-PROG=./dbtest
-TMP1=t1
-TMP2=t2
-TMP3=t3
+        PROG=./dbtest
+        TMP1=t1
+        TMP2=t2
+        TMP3=t3
 
+        if [ -f /usr/share/dict/words ]; then
+                DICT=/usr/share/dict/words
+        elif [ -f /usr/dict/words ]; then
+                DICT=/usr/dict/words
+        else
+                echo 'run.test: no dictionary'
+                exit 1
+        fi
+        
         if [ $# -eq 0 ]; then
                 for t in 1 2 3 4 5 6 7 8 9 10 11 12 13 20; do
                         test$t
@@ -345,7 +354,7 @@ test7()
                 for (i = 1; i <= 120; ++i)
                         printf("%05d: input key %d: %s\n", i, i, $0);
                 printf("%05d: input key %d: %s\n", 120, 120, $0);
-                printf("get failed, no such key\n");
+                printf("seq failed, no such key\n");
                 printf("%05d: input key %d: %s\n", 1, 1, $0);
                 printf("%05d: input key %d: %s\n", 2, 2, $0);
                 exit;
@@ -364,10 +373,10 @@ test7()
                         for (i = 1; i <= 120; ++i)
                                 printf("s\n");
                         printf("fR_CURSOR\ns\nk120\n");
-                        printf("r\nk120\n");
+                        printf("r\n");
                         printf("fR_NEXT\ns\n");
                         printf("fR_CURSOR\ns\nk1\n");
-                        printf("r\nk1\n");
+                        printf("r\n");
                         printf("fR_FIRST\ns\n");
                 }' > $TMP2
                 $PROG -o $TMP3 recno $TMP2
@@ -397,8 +406,6 @@ test8()
                                 printf("e\t%d of 10             \n", i);
                         printf("r\nkkey1\nr\nkkey2\n");
                 }
-                printf("e\n");
-                printf("eend of test8 run\n");
         }' > $TMP1
         $PROG btree $TMP1
 #       $PROG hash $TMP1
@@ -459,7 +466,7 @@ test10()
                         printf("p\nk%d\nd%s\n", ++i, $0);
                 }
                 END {
-                        printf("fR_CURSOR\nr\nk1\n");
+                        printf("fR_CURSOR\nr\n");
                         printf("eR_CURSOR SHOULD HAVE FAILED\n");
                 }' > $TMP2
                 $PROG -o $TMP3 $type $TMP2 > /dev/null 2>&1
@@ -573,7 +580,8 @@ test13()
                                 echo g
                                 echo k$i
                         done > $TMP2
-                        $PROG -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
+                        $PROG -s \
+                            -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
                         if (cmp -s $TMP1 $TMP3) ; then :
                         else
                                 echo "test13: $type/$order get failed"
diff --git a/src/regress/lib/libc/dirname/Makefile b/src/regress/lib/libc/dirname/Makefile
new file mode 100644
index 0000000000..fc152df954
--- /dev/null
+++ b/src/regress/lib/libc/dirname/Makefile
@@ -0,0 +1,3 @@
+PROG=dirname_test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/dirname/dirname_test.c b/src/regress/lib/libc/dirname/dirname_test.c
new file mode 100644
index 0000000000..add76980cf
--- /dev/null
+++ b/src/regress/lib/libc/dirname/dirname_test.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2007 Bret S. Lambert <blambert@gsipt.net>
+ *
+ * Public domain.
+ */
+
+#include <sys/param.h>
+
+#include <libgen.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+int
+main(void)
+{
+        char path[2 * MAXPATHLEN];
+        char dname[128];
+        const char *dir = "junk";
+        const char *fname = "/file.name.ext";
+        char *str;
+        int i;
+
+        /* Test normal functioning */
+        strlcpy(path, "/", sizeof(path));
+        strlcpy(dname, "/", sizeof(dname));
+        strlcat(path, dir, sizeof(path)); 
+        strlcat(dname, dir, sizeof(dname)); 
+        strlcat(path, fname, sizeof(path));
+        str = dirname(path);
+        if (strcmp(str, dname) != 0)
+                errx(1, "0: dirname(%s) = %s != %s", path, str, dname);
+
+        /*
+         * There are four states that require special handling:
+         *
+         * 1) path is NULL
+         * 2) path is the empty string
+         * 3) path is composed entirely of slashes
+         * 4) the resulting name is larger than MAXPATHLEN
+         *
+         * The first two cases require that a pointer
+         * to the string "." be returned.
+         *
+         * The third case requires that a pointer
+         * to the string "/" be returned.
+         *
+         * The final case requires that NULL be returned
+         * and errno * be set to ENAMETOOLONG.
+         */
+        /* Case 1 */
+        str = dirname(NULL);
+        if (strcmp(str, ".") != 0)
+                errx(1, "1: dirname(NULL) = %s != .", str);
+
+        /* Case 2 */
+        strlcpy(path, "", sizeof(path));
+        str = dirname(path);
+        if (strcmp(str, ".") != 0)
+                errx(1, "2: dirname(%s) = %s != .", path, str);
+
+        /* Case 3 */
+        for (i = 0; i < MAXPATHLEN - 1; i++)
+                strlcat(path, "/", sizeof(path));       /* path cleared above */
+        str = dirname(path);
+        if (strcmp(str, "/") != 0)
+                errx(1, "3: dirname(%s) = %s != /", path, str);
+
+        /* Case 4 */
+        strlcpy(path, "/", sizeof(path));               /* reset path */
+        for (i = 0; i <= MAXPATHLEN; i += strlen(dir))
+                strlcat(path, dir, sizeof(path));
+        strlcat(path, fname, sizeof(path));
+        str = dirname(path);
+        if (str != NULL)
+                errx(1, "4: dirname(%s) = %s != NULL", path, str);
+        if (errno != ENAMETOOLONG)
+                errx(1, "4: dirname(%s) sets errno to %d", path, errno);
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/env/Makefile b/src/regress/lib/libc/env/Makefile
new file mode 100644
index 0000000000..92e04369f4
--- /dev/null
+++ b/src/regress/lib/libc/env/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2010/08/23 22:34:37 millert Exp $
+
+PROG=   envtest
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/env/envtest.c b/src/regress/lib/libc/env/envtest.c
new file mode 100644
index 0000000000..33fc463404
--- /dev/null
+++ b/src/regress/lib/libc/env/envtest.c
@@ -0,0 +1,125 @@
+/*      $OpenBSD: envtest.c,v 1.1 2010/08/23 22:34:37 millert Exp $ */
+
+/*
+ * Copyright (c) 2010 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+extern char **environ;
+
+static int
+count_instances(const char *name)
+{
+        int count = 0;
+        size_t namelen;
+        char **ep;
+
+        namelen = strlen(name);
+        for (ep = environ; *ep != NULL; ep++) {
+                if (strncmp(name, *ep, namelen) == 0 && (*ep)[namelen] == '=')
+                        count++;
+        }
+
+        return count;
+}
+
+static void
+fake_env(void)
+{
+        static char *fakenv[7];
+
+        fakenv[0] = "HOME=/root";
+        fakenv[1] = "USER=root";
+        fakenv[2] = "LOGNAME=root";
+        fakenv[3] = "SHELL=/bin/sh";
+        fakenv[4] = "USER=root";
+        fakenv[5] = NULL;
+
+        environ = fakenv;
+}
+
+int
+main(int argc, char *argv[])
+{
+        char *buf;
+        int n, failures = 0;
+        size_t len, bufsize;
+
+        /* Enable malloc security options. */
+        setenv("MALLOC_OPTIONS", "S", 0);
+
+        fake_env();
+        n = count_instances("USER");
+        if (n != 2) {
+                fprintf(stderr, "initial: %d instances of USER, expected %d\n",
+                    n, 2);
+                failures++;
+        }
+
+        if (unsetenv("USER") != 0) {
+                fprintf(stderr, "unsetenv: failed to remove USER\n");
+                failures++;
+        }
+        n = count_instances("USER");
+        if (n != 0) {
+                fprintf(stderr, "unsetenv: %d instances of USER, expected %d\n",
+                    n, 0);
+                failures++;
+        }
+
+        fake_env();
+        if (setenv("USER", "nobody", 0) != 0) {
+                fprintf(stderr, "setenv: failed to set USER\n");
+                failures++;
+        }
+        n = count_instances("USER");
+        if (n != 2) {
+                fprintf(stderr, "setenv: %d instances of USER, expected %d\n",
+                    n, 2);
+                failures++;
+        }
+
+        fake_env();
+        if (setenv("USER", "nobody", 1) != 0) {
+                fprintf(stderr, "setenv: failed to set USER\n");
+                failures++;
+        }
+        n = count_instances("USER");
+        if (n != 1) {
+                fprintf(stderr, "setenv: %d instances of USER, expected %d\n",
+                    n, 1);
+                failures++;
+        }
+
+        fake_env();
+        if (putenv("USER=nobody") != 0) {
+                fprintf(stderr, "putenv: failed to set USER\n");
+                failures++;
+        }
+        n = count_instances("USER");
+        if (n != 1) {
+                fprintf(stderr, "putenv: %d instances of USER, expected %d\n",
+                    n, 1);
+                failures++;
+        }
+
+        return failures;
+}
diff --git a/src/regress/lib/libc/fnmatch/Makefile b/src/regress/lib/libc/fnmatch/Makefile
new file mode 100644
index 0000000000..4acdd351bc
--- /dev/null
+++ b/src/regress/lib/libc/fnmatch/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.2 2011/09/17 15:12:38 stsp Exp $
+
+PROG=   fnm_test
+LDADD+= -lutil
+DPADD+= ${LIBUTIL}
+
+run-regress-${PROG}:
+        ./${PROG} ${.CURDIR}/${PROG}.in
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/fnmatch/fnm_test.c b/src/regress/lib/libc/fnmatch/fnm_test.c
new file mode 100644
index 0000000000..f5958837e2
--- /dev/null
+++ b/src/regress/lib/libc/fnmatch/fnm_test.c
@@ -0,0 +1,62 @@
+/*      $OpenBSD: fnm_test.c,v 1.2 2011/09/17 15:12:38 stsp Exp $       */
+
+/*
+ * Public domain, 2008, Todd C. Miller <Todd.Miller@courtesan.com>
+ */
+
+#include <err.h>
+#include <fnmatch.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <util.h>
+
+int
+main(int argc, char **argv)
+{
+        FILE *fp = stdin;
+        char pattern[1024], string[1024];
+        char *line;
+        const char delim[3] = {'\0', '\0', '#'};
+        int errors = 0, flags, got, want;
+
+        if (argc > 1) {
+                if ((fp = fopen(argv[1], "r")) == NULL)
+                        err(1, "%s", argv[1]);
+        }
+
+        /*
+         * Read in test file, which is formatted thusly:
+         *
+         * pattern string flags expected_result
+         *
+         * lines starting with '#' are comments
+         */
+        for (;;) {
+                line = fparseln(fp, NULL, NULL, delim, 0);
+                if (!line)
+                        break;
+                got = sscanf(line, "%s %s 0x%x %d", pattern, string, &flags,
+                    &want);
+                if (got == EOF) {
+                        free(line);
+                        break;
+                }
+                if (pattern[0] == '#') {
+                        free(line);
+                        continue;
+                }
+                if (got == 4) {
+                        got = fnmatch(pattern, string, flags);
+                        if (got != want) {
+                                warnx("%s %s %d: want %d, got %d", pattern,
+                                    string, flags, want, got);
+                                errors++;
+                        }
+                } else {
+                        warnx("unrecognized line '%s'\n", line);
+                        errors++;
+                }
+                free(line);
+        }
+        exit(errors);
+}
diff --git a/src/regress/lib/libc/fnmatch/fnm_test.in b/src/regress/lib/libc/fnmatch/fnm_test.in
new file mode 100644
index 0000000000..c20077966d
--- /dev/null
+++ b/src/regress/lib/libc/fnmatch/fnm_test.in
@@ -0,0 +1,259 @@
+/bin/[[:alpha:][:alnum:]]* /bin/ls 0x2 0
+/bin/[[:upper:]][[:alnum:]] /bin/ls 0x10 0
+/bin/[[:opper:][:alnum:]]* /bin/ls 0x0 1
+[[:alpha:][:alnum:]]*.c foo1.c 0x4 0
+[[:upper:]]* FOO 0x0 0
+# 'te\st' 'test'; no match if FNM_NOESCAPE
+te\st test 0x0 0  
+te\st test 0x1 1
+te\st test 0x1e 0
+# 'te\\st' 'te\st'; no match if FNM_NOESCAPE
+te\\st te\st 0x0 0
+te\\st te\st 0x1 1
+te\\st te\st 0x1e 0
+# 'te\*t' 'te*t'; no match if FNM_NOESCAPE
+te\*t te*t 0x0 0
+te\*t te*t 0x1 1
+te\*t te*t 0x1e 0
+# 'te\*t' 'test'; no match
+te\*t test 0x0 1
+te\*t test 0x1f 1
+# 'te\?t' 'te?t'; no match if FNM_NOESCAPE
+te\?t te?t 0x0 0
+te\?t te?t 0x1 1
+te\?t te?t 0x1e 0
+# 'te\?t' 'test'; no match
+te\?t test 0x0 1
+te\?t test 0x1f 1
+# 'tesT' 'test'; match if FNM_CASEFOLD
+tesT test 0x0 1
+tesT test 0xf 1
+tesT test 0x10 0
+# 'test' 'Test'; match if FNM_CASEFOLD
+test Test 0x0 1
+test Test 0xf 1
+test Test 0x10 0
+# 'tEst' 'teSt'; match if FNM_CASEFOLD
+tEst teSt 0x0 1
+tEst teSt 0xf 1
+tEst teSt 0x10 0
+# '?est' 'test'; match always
+?est test 0x0 0
+?est test 0x1f 0
+# 'te?t' 'test'; match always
+te?t test 0x0 0
+te?t test 0x1f 0
+# 'tes?' 'test'; match always
+tes? test 0x0 0
+tes? test 0x1f 0
+# 'test?' 'test'; no match
+test? test 0x0 1
+test? test 0x1f 1
+# '*' always matches anything
+*  test 0x0 0
+*  test 0x1f 0
+# '*test' 'test'; match always
+*test test 0x0 0
+*test test 0x1f 0
+# '*est' 'test'; match always
+*est test 0x0 0
+*est test 0x1f 0
+# '*st' 'test'; match always
+*st test 0x0 0
+*st test 0x1f 0
+# 't*t' 'test'; match always
+t*t test 0x0 0
+t*t test 0x1f 0
+# 'te*t' 'test'; match always
+te*t test 0x0 0
+te*t test 0x1f 0
+# 'te*st' 'test'; match always
+te*st test 0x0 0
+te*st test 0x1f 0
+# 'te*' 'test'; match always
+te* test 0x0 0
+te* test 0x1f 0
+# 'tes*' 'test'; match always
+tes* test 0x0 0
+tes* test 0x1f 0
+# 'test*' 'test'; match always
+test* test 0x0 0
+test* test 0x1f 0
+# '.[\-\t]' '.t'; match always
+.[\-\t] .t 0x0 0
+.[\-\t] .t 0x1f 0
+# 'test*?*[a-z]*' 'testgoop'; match always
+test*?*[a-z]* testgoop 0x0 0
+test*?*[a-z]* testgoop 0x1f 0
+# 'te[^abc]t' 'test'; match always
+te[^abc]t test 0x0 0
+te[^abc]t test 0x1f 0
+# 'te[^x]t' 'test'; match always
+te[^x]t test 0x0 0
+te[^x]t test 0x1f 0
+# 'te[!x]t' 'test'; match always
+te[!x]t test 0x0 0
+te[^x]t test 0x1f 0
+# 'te[^x]t' 'text'; no match
+te[^x]t text 0x0 1
+te[^x]t text 0x1f 1
+# 'te[^\x]t' 'text'; no match
+te[^\x]t text 0x0 1
+te[^\x]t text 0x1f 1
+# 'te[^\x' 'text'; no match
+te[^\x text 0x0 1
+te[^\x text 0x1f 1
+# 'te[/]t' 'text'; no match
+te[/]t text 0x0 1
+te[/]t text 0x1f 1
+# 'te[S]t' 'test'; match if FNM_CASEFOLD
+te[S]t test 0x0 1
+te[S]t test 0xf 1
+te[S]t test 0x10 0
+# 'te[r-t]t' 'test'; match always
+te[r-t]t test 0x0 0
+te[r-t]t test 0x1f 0
+# 'te[r-t]t' 'teSt'; match if FNM_CASEFOLD
+te[r-t]t teSt 0x0 1
+te[r-t]t teSt 0xf 1
+te[r-t]t teSt 0x10 0
+# 'te[r-T]t' 'test'; match if FNM_CASEFOLD
+te[r-T]t test 0x0 1
+te[r-T]t test 0xf 1
+te[r-T]t test 0x10 0
+# 'te[R-T]t' 'test'; match if FNM_CASEFOLD
+te[R-T]t test 0x0 1
+te[R-T]t test 0xf 1
+te[R-T]t test 0x10 0
+# 'te[r-Tz]t' 'tezt'; match always
+te[r-Tz]t tezt 0x0 0
+te[r-Tz]t tezt 0x1f 0
+# 'te[R-T]t' 'tent'; no match
+te[R-T]t tent 0x0 1
+te[R-T]t tent 0x1f 1
+# 'tes[]t]' 'test'; match always
+tes[]t] test 0x0 0
+tes[]t] test 0x1f 0
+# 'tes[t-]' 'test'; match always
+tes[t-] test 0x0 0
+tes[t-] test 0x1f 0
+# 'tes[t-]]' 'test]'; match always
+tes[t-]] test] 0x0 0
+tes[t-]] test] 0x1f 0
+# 'tes[t-]]' 'test'; no match
+tes[t-]] test 0x0 1
+tes[t-]] test 0x1f 1
+# 'tes[u-]' 'test'; no match
+tes[u-] test 0x0 1
+tes[u-] test 0x1f 1
+# 'tes[t-]' 'tes[t-]'; no match
+tes[t-] test[t-] 0x0 1
+tes[t-] test[t-] 0x1f 1
+# 'test[/-/]' 'test[/-/]'; no match
+test[/-/] test/-/ 0x0 1
+test[/-/] test/-/ 0x1f 1
+# 'test[\/-/]' 'test[/-/]'; no match
+test[\/-/] test/-/ 0x0 1
+test[\/-/] test/-/ 0x1f 1
+# 'test[/-\/]' 'test[/-/]'; no match
+test[/-\/] test/-/ 0x0 1
+test[/-\/] test/-/ 0x1f 1
+# 'test[/-/]' 'test/'; no match if APR_FNM_PATHNAME
+test[/-/] test/ 0x0 0
+test[/-/] test/ 0x2 1
+test[/-/] test/ 0x1d 0
+# 'test[\/-/]' 'test/'; no match if APR_FNM_PATHNAME
+test[\/-/] test/ 0x0 0
+test[\/-/] test/ 0x2 1
+test[\/-/] test/ 0x1d 0
+# 'test[/-\/]' 'test/'; no match if APR_FNM_PATHNAME
+test[/-\/] test/ 0x0 0
+test[/-\/] test/ 0x2 1
+test[/-\/] test/ 0x1d 0
+# '/test' 'test'; no match
+/test test 0x0 1
+/test test 0x1f 1
+# 'test' '/test'; no match
+test /test 0x0 1
+test /test 0x1f 1
+# 'test/' 'test'; no match
+test/ test 0x0 1
+test/ test 0x1f 1
+# 'test' 'test/'; match if FNM_LEADING_DIR
+test test/ 0x0 1
+test test/ 0x17 1
+test test/ 0x8 0
+# '\/test' '/test'; match unless FNM_NOESCAPE
+\/test /test 0x0 0
+\/test /test 0x1 1
+\/test /test 0x1e 0
+# '*test' '/test'; match unless FNM_PATHNAME
+*test /test 0x0 0
+*test /test 0x2 1
+*test /test 0x1d 0
+# '/*/test' '/test'; no match
+/*/test /test 0x0 1
+/*/test /test 0x1f 1
+# '/*/test' '/test/test'; match always
+/*/test /test/test 0x0 0
+/*/test /test/test 0x1f 0
+# 'test/this' 'test/'; match never
+test/this test/ 0x0 1
+test/this test/ 0x1f 1
+# 'test/' 'test/this'; match never
+test/ test/this 0x0 1
+test/ test/this 0x1f 1
+# 'test*/this' 'test/this'; match always
+test*/this test/this 0x0 0
+test*/this test/this 0x1f 0
+# 'test*/this' 'test/that'; match never
+test*/this test/that 0x0 1
+test*/this test/that 0x1f 1
+# 'test/*this' 'test/this'; match always
+test/*this test/this 0x0 0
+test/*this test/this 0x1f 0
+# '.*' '.this'; match always
+.* .this 0x0 0
+.* .this 0x1f 0
+# '*' '.this'; fails if FNM_PERIOD
+* .this 0x0 0
+* .this 0x4 1
+* .this 0x1b 0
+# '?this' '.this'; fails if FNM_PERIOD
+?this .this 0x0 0
+?this .this 0x4 1
+?this .this 0x1b 0
+# '[.]this' '.this'; fails if FNM_PERIOD
+[.]this .this 0x0 0
+[.]this .this 0x4 1
+[.]this .this 0x1b 0
+# 'test/this' 'test/this'; match always
+test/this test/this 0x0 0
+test/this test/this 0x1f 0
+# 'test?this' 'test/this'; fails if FNM_PATHNAME
+test?this test/this 0x0 0
+test?this test/this 0x2 1
+test?this test/this 0x1d 0
+# 'test*this' 'test/this'; fails if FNM_PATHNAME
+test*this test/this 0x0 0
+test*this test/this 0x2 1
+test*this test/this 0x1d 0
+# 'test[/]this' 'test/this'; fails if FNM_PATHNAME
+test[/]this test/this 0x0 0
+test[/]this test/this 0x2 1
+test[/]this test/this 0x1d 0
+# 'test/.*' 'test/.this'; match always
+test/.* test/.this 0x0 0
+test/.* test/.this 0x1f 0
+# 'test/*' 'test/.this'; fails if FNM_PERIOD and FNM_PATHNAME
+test/* test/.this 0x0 0
+test/* test/.this 0x6 1
+test/* test/.this 0x19 0
+# 'test/?' 'test/.this'; fails if FNM_PERIOD and FNM_PATHNAME
+test/?this test/.this 0x0 0
+test/?this test/.this 0x6 1
+test/?this test/.this 0x19 0
+# 'test/[.]this' 'test/.this'; fails if FNM_PERIOD and FNM_PATHNAME
+test/[.]this test/.this 0x0 0
+test/[.]this test/.this 0x6 1
+test/[.]this test/.this 0x19 0
diff --git a/src/regress/lib/libc/fpclassify/Makefile b/src/regress/lib/libc/fpclassify/Makefile
new file mode 100644
index 0000000000..96916d20e7
--- /dev/null
+++ b/src/regress/lib/libc/fpclassify/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2008/09/07 20:36:10 martynas Exp $
+
+PROG=   fpclassify
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/fpclassify/fpclassify.c b/src/regress/lib/libc/fpclassify/fpclassify.c
new file mode 100644
index 0000000000..174c04d983
--- /dev/null
+++ b/src/regress/lib/libc/fpclassify/fpclassify.c
@@ -0,0 +1,76 @@
+/*      $OpenBSD: fpclassify.c,v 1.1 2008/09/07 20:36:10 martynas Exp $ */
+/*-
+ * Copyright (c) 2003 Mike Barcroft <mike@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: src/tools/regression/lib/libc/gen/test-fpclassify.c,v 1.3 2003/03/27 05:32:28 das Exp $
+ */
+
+#include <assert.h>
+#include <float.h>
+#include <math.h>
+#include <stdlib.h>
+
+int
+main(void)
+{
+
+        assert(fpclassify((float)0) == FP_ZERO);
+        assert(fpclassify((float)-0.0) == FP_ZERO);
+        assert(fpclassify((float)1) == FP_NORMAL);
+        assert(fpclassify((float)1000) == FP_NORMAL);
+#ifndef __alpha__
+        assert(fpclassify(0x1.2p-150f) == FP_SUBNORMAL);
+#endif /* !__alpha__ */
+        assert(fpclassify(HUGE_VALF) == FP_INFINITE);
+        assert(fpclassify((float)HUGE_VAL) == FP_INFINITE);
+        assert(fpclassify((float)HUGE_VALL) == FP_INFINITE);
+        assert(fpclassify(NAN) == FP_NAN);
+
+        assert(fpclassify((double)0) == FP_ZERO);
+        assert(fpclassify((double)-0) == FP_ZERO);
+        assert(fpclassify((double)1) == FP_NORMAL);
+        assert(fpclassify((double)1000) == FP_NORMAL);
+#ifndef __alpha__
+        assert(fpclassify(0x1.2p-1075) == FP_SUBNORMAL);
+#endif /* !__alpha__ */
+        assert(fpclassify(HUGE_VAL) == FP_INFINITE);
+        assert(fpclassify((double)HUGE_VALF) == FP_INFINITE);
+        assert(fpclassify((double)HUGE_VALL) == FP_INFINITE);
+        assert(fpclassify((double)NAN) == FP_NAN);
+
+        assert(fpclassify((long double)0) == FP_ZERO);
+        assert(fpclassify((long double)-0.0) == FP_ZERO);
+        assert(fpclassify((long double)1) == FP_NORMAL);
+        assert(fpclassify((long double)1000) == FP_NORMAL);
+#if (LDBL_MANT_DIG > DBL_MANT_DIG)
+        assert(fpclassify(0x1.2p-16383L) == FP_SUBNORMAL);
+#endif /* (LDBL_MANT_DIG > DBL_MANT_DIG) */
+        assert(fpclassify(HUGE_VALL) == FP_INFINITE);
+        assert(fpclassify((long double)HUGE_VALF) == FP_INFINITE);
+        assert(fpclassify((long double)HUGE_VAL) == FP_INFINITE);
+        assert(fpclassify((long double)NAN) == FP_NAN);
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/gcvt/Makefile b/src/regress/lib/libc/gcvt/Makefile
new file mode 100644
index 0000000000..d8efaa9362
--- /dev/null
+++ b/src/regress/lib/libc/gcvt/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2010/09/17 19:51:38 millert Exp $
+
+PROG=   gcvt_test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/gcvt/gcvt_test.c b/src/regress/lib/libc/gcvt/gcvt_test.c
new file mode 100644
index 0000000000..164d600cd2
--- /dev/null
+++ b/src/regress/lib/libc/gcvt/gcvt_test.c
@@ -0,0 +1,120 @@
+/*      $OpenBSD: gcvt_test.c,v 1.4 2010/09/18 20:29:15 millert Exp $   */
+
+/*
+ * Public domain, 2010, Todd C. Miller <Todd.Miller@courtesan.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static struct test_vector {
+        double d;
+        int ndig;
+        char *expect;
+} test_vectors[] = {
+        /* adapted from perl's Configure test */
+        { 0.1, 8, "0.1" },
+        { 0.01, 8, "0.01" },
+        { 0.001, 8, "0.001" },
+        { 0.0001, 8, "0.0001" },
+        { 0.00009, 8, "9e-05" },
+        { 1.0, 8, "1" },
+        { 1.1, 8, "1.1" },
+        { 1.01, 8, "1.01" },
+        { 1.001, 8, "1.001" },
+        { 1.0001, 8, "1.0001" },
+        { 1.00001, 8, "1.00001" },
+        { 1.000001, 8, "1.000001" },
+        { 0.0, 8, "0" },
+        { -1.0, 8, "-1" },
+        { 100000.0, 8, "100000" },
+        { -100000.0, 8, "-100000" },
+        { 123.456, 8, "123.456" },
+        { 1e34, 8, "1e+34" },
+        /* adapted from emx */
+        { 0.0, -1, "0" },
+        { 0.0, 0, "0" },
+        { 0.0, 1, "0" },
+        { 0.0, 2, "0" },
+        { 1.0, -1, "1" },
+        { 1.0, 0, "1" },
+        { 1.0, 2, "1" },
+        { 1.0, 10, "1" },
+        { 1.236, -1, "1.236" },
+        { 1.236, 0, "1" },
+        { 1.236, 1, "1" },
+        { 1.236, 2, "1.2" },
+        { 1.236, 3, "1.24" },
+        { 1.236, 4, "1.236" },
+        { 1.236, 5, "1.236" },
+        { 1.236, 6, "1.236" },
+        { 12.36, -1, "12.36" },
+        { 12.36, 0, "1e+01" },
+        { 12.36, 1, "1e+01" },
+        { 12.36, 2, "12" },
+        { 12.36, 3, "12.4" },
+        { 12.36, 4, "12.36" },
+        { 12.36, 5, "12.36" },
+        { 12.36, 6, "12.36" },
+        { 123.6, -1, "123.6" },
+        { 123.6, 0, "1e+02" },
+        { 123.6, 1, "1e+02" },
+        { 123.6, 2, "1.2e+02" },
+        { 123.6, 3, "124" },
+        { 123.6, 4, "123.6" },
+        { 123.6, 5, "123.6" },
+        { 123.6, 6, "123.6" },
+        { 1236.0, -1, "1236" },
+        { 1236.0, 0, "1e+03" },
+        { 1236.0, 1, "1e+03" },
+        { 1236.0, 2, "1.2e+03" },
+        { 1236.0, 3, "1.24e+03" },
+        { 1236.0, 4, "1236" },
+        { 1236.0, 5, "1236" },
+        { 1236.0, 6, "1236" },
+        { 1e100, 10, "1e+100" },
+        { 1e100, 20, "1.0000000000000000159e+100" },
+        { 0.01236, -1, "0.01236" },
+        { 0.01236, 0, "0.01" },
+        { 0.01236, 1, "0.01" },
+        { 0.01236, 2, "0.012" },
+        { 0.01236, 3, "0.0124" },
+        { 0.01236, 4, "0.01236" },
+        { 1e-100, 20, "1.00000000000000002e-100" },
+        { 1e-100, -1, "1e-100" },
+        { -1.2, 5, "-1.2" },
+        { -0.03, 5, "-0.03" },
+        { 0.1, 1, "0.1" },
+        { 0.1, 0, "0.1" },
+        { 0.099999, 10, "0.099999" },
+        { 0.99999, 10, "0.99999" },
+};
+
+#define NTESTVEC (sizeof(test_vectors) / sizeof(test_vectors[0]))
+
+static int
+dotest(struct test_vector *tv)
+{
+        char buf[256], *got;
+
+        got = gcvt(tv->d, tv->ndig, buf);
+        if (strcmp(tv->expect, got) != 0) {
+                fprintf(stderr, "%g @ %d: expected %s, got %s\n",
+                    tv->d, tv->ndig, tv->expect, got);
+                return 1;
+        }
+        return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+        int i, failures = 0;
+
+        for (i = 0; i < NTESTVEC; i++) {
+                failures += dotest(&test_vectors[i]);
+        }
+
+        return failures;
+}
diff --git a/src/regress/lib/libc/getaddrinfo/Makefile b/src/regress/lib/libc/getaddrinfo/Makefile
new file mode 100644
index 0000000000..d93494cc1c
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.4 2011/07/07 21:00:59 deraadt Exp $
+
+PROG=           gaitest
+SRCS=           gaitest.c
+NOMAN=          # defined
+CLEANFILES+=    out
+
+REGRESS_TARGETS=do-test
+
+do-test: ${PROG}
+        sh ${.CURDIR}/testsuite.sh >out 2>&1
+        @if diff -u10 out ${.CURDIR}/answer; then \
+                echo SUCCESS; \
+        else \
+                echo FAIL; \
+                exit 1; \
+        fi
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/getaddrinfo/answer b/src/regress/lib/libc/getaddrinfo/answer
new file mode 100644
index 0000000000..778fc64baa
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/answer
@@ -0,0 +1,110 @@
+== basic ones
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host ::1 serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host 127.0.0.1 serv http
+ai1: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host localhost serv http
+ai1: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+ai2: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host ::1 serv tftp
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 69
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host 127.0.0.1 serv tftp
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 69
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host localhost serv tftp
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 69
+ai2: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 69
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host ::1 serv echo
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 7
+ai2: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 7
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host 127.0.0.1 serv echo
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 7
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 7
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host localhost serv echo
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 7
+ai2: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 7
+ai3: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 7
+ai4: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 7
+
+== specific address family
+arg: flags 0x2 family 2 socktype 0 protocol 0 addrlen 0 host localhost serv http
+ai1: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 24 socktype 0 protocol 0 addrlen 0 host localhost serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+
+== empty hostname
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv echo
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 7
+ai2: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 7
+ai3: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 7
+ai4: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 7
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv tftp
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 69
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 69
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv 80
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 80
+ai2: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+ai3: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 80
+ai4: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x3 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv http
+ai1: flags 0x3 family 24 socktype 1 protocol 6 addrlen 28 host :: serv 80
+ai2: flags 0x3 family 2 socktype 1 protocol 6 addrlen 16 host 0.0.0.0 serv 80
+arg: flags 0x3 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv echo
+ai1: flags 0x3 family 24 socktype 2 protocol 17 addrlen 28 host :: serv 7
+ai2: flags 0x3 family 24 socktype 1 protocol 6 addrlen 28 host :: serv 7
+ai3: flags 0x3 family 2 socktype 2 protocol 17 addrlen 16 host 0.0.0.0 serv 7
+ai4: flags 0x3 family 2 socktype 1 protocol 6 addrlen 16 host 0.0.0.0 serv 7
+arg: flags 0x3 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv tftp
+ai1: flags 0x3 family 24 socktype 2 protocol 17 addrlen 28 host :: serv 69
+ai2: flags 0x3 family 2 socktype 2 protocol 17 addrlen 16 host 0.0.0.0 serv 69
+arg: flags 0x3 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv 80
+ai1: flags 0x3 family 24 socktype 2 protocol 17 addrlen 28 host :: serv 80
+ai2: flags 0x3 family 24 socktype 1 protocol 6 addrlen 28 host :: serv 80
+ai3: flags 0x3 family 2 socktype 2 protocol 17 addrlen 16 host 0.0.0.0 serv 80
+ai4: flags 0x3 family 2 socktype 1 protocol 6 addrlen 16 host 0.0.0.0 serv 80
+arg: flags 0x2 family 0 socktype 1 protocol 0 addrlen 0 host (empty) serv 80
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 0 socktype 2 protocol 0 addrlen 0 host (empty) serv 80
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 80
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 80
+
+== empty servname
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host ::1 serv (empty)
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 0
+ai2: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 0
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host 127.0.0.1 serv (empty)
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 0
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 0
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host localhost serv (empty)
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 0
+ai2: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 0
+ai3: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 0
+ai4: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 0
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv (empty)
+name or service is not known
+
+== sock_raw
+arg: flags 0x2 family 0 socktype 3 protocol 0 addrlen 0 host localhost serv (empty)
+ai1: flags 0x2 family 2 socktype 3 protocol 0 addrlen 16 host 127.0.0.1 serv 0
+ai2: flags 0x2 family 24 socktype 3 protocol 0 addrlen 28 host ::1 serv 0
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host localhost serv (empty)
+ai1: flags 0x2 family 2 socktype 3 protocol 59 addrlen 16 host 127.0.0.1 serv 0
+ai2: flags 0x2 family 24 socktype 3 protocol 59 addrlen 28 host ::1 serv 0
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host localhost serv 80
+service not supported for ai_socktype
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host localhost serv www
+service not supported for ai_socktype
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host ::1 serv (empty)
+ai1: flags 0x2 family 24 socktype 3 protocol 59 addrlen 28 host ::1 serv 0
+
+== unsupported family
+arg: flags 0x2 family 99 socktype 0 protocol 0 addrlen 0 host localhost serv (empty)
+ai_family not supported
+
+== the following items are specified in jinmei scopeaddr format doc.
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host fe80::1%lo0 serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host fe80::1%lo0 serv 80
+
diff --git a/src/regress/lib/libc/getaddrinfo/gaitest.c b/src/regress/lib/libc/getaddrinfo/gaitest.c
new file mode 100644
index 0000000000..12a4498459
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/gaitest.c
@@ -0,0 +1,195 @@
+/*      $OpenBSD: gaitest.c,v 1.6 2009/06/09 18:15:08 phessler Exp $    */
+/*      $NetBSD: gaitest.c,v 1.3 2002/07/05 15:47:43 itojun Exp $       */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, and 2002 WIDE Project.
+ * 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.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT 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 PROJECT 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.
+ */
+
+/*
+ * Please note: the order of the responses (and the regress test)
+ * is dependent on the "family" keywords in resolv.conf.
+ *
+ * This expects the default behaviour of "family inet4 inet6"
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+struct addrinfo ai;
+
+char host[NI_MAXHOST];
+char serv[NI_MAXSERV];
+int vflag = 0;
+
+static void usage(void);
+static void print1(const char *, const struct addrinfo *, char *, char *);
+int main(int, char *[]);
+
+static void
+usage()
+{
+        fprintf(stderr, "usage: test [-f family] [-s socktype] [-p proto] [-DPRSv46] host serv\n");
+}
+
+static void
+print1(title, res, h, s)
+        const char *title;
+        const struct addrinfo *res;
+        char *h;
+        char *s;
+{
+        char *start, *end;
+        int error;
+        const int niflag = NI_NUMERICHOST | NI_NUMERICSERV;
+
+        if (res->ai_addr) {
+                error = getnameinfo(res->ai_addr, res->ai_addr->sa_len,
+                                    host, sizeof(host), serv, sizeof(serv),
+                                    niflag);
+                h = host;
+                s = serv;
+        } else
+                error = 0;
+
+        if (vflag) {
+                start = "\t";
+                end = "\n";
+        } else {
+                start = " ";
+                end = "";
+        }
+        printf("%s%s", title, end);
+        printf("%sflags 0x%x%s", start, res->ai_flags, end);
+        printf("%sfamily %d%s", start, res->ai_family, end);
+        printf("%ssocktype %d%s", start, res->ai_socktype, end);
+        printf("%sprotocol %d%s", start, res->ai_protocol, end);
+        printf("%saddrlen %d%s", start, res->ai_addrlen, end);
+        if (error)
+                printf("%serror %d%s", start, error, end);
+        else {
+                printf("%shost %s%s", start, h, end);
+                printf("%sserv %s%s", start, s, end);
+        }
+#if 0
+        if (res->ai_canonname)
+                printf("%scname \"%s\"%s", start, res->ai_canonname, end);
+#endif
+        if (!vflag)
+                printf("\n");
+
+}
+
+int
+main(argc, argv)
+        int argc;
+        char *argv[];
+{
+        struct addrinfo *res;
+        int error, i;
+        char *p, *q;
+        extern int optind;
+        extern char *optarg;
+        int c;
+        char nbuf[10];
+
+        memset(&ai, 0, sizeof(ai));
+        ai.ai_family = PF_UNSPEC;
+        ai.ai_flags |= AI_CANONNAME;
+        while ((c = getopt(argc, argv, "Df:p:PRs:Sv46")) != -1) {
+                switch (c) {
+                case 'D':
+                        ai.ai_socktype = SOCK_DGRAM;
+                        break;
+                case 'f':
+                        ai.ai_family = atoi(optarg);
+                        break;
+                case 'p':
+                        ai.ai_protocol = atoi(optarg);
+                        break;
+                case 'P':
+                        ai.ai_flags |= AI_PASSIVE;
+                        break;
+                case 'R':
+                        ai.ai_socktype = SOCK_RAW;
+                        break;
+                case 's':
+                        ai.ai_socktype = atoi(optarg);
+                        break;
+                case 'S':
+                        ai.ai_socktype = SOCK_STREAM;
+                        break;
+                case 'v':
+                        vflag++;
+                        break;
+                case '4':
+                        ai.ai_family = PF_INET;
+                        break;
+                case '6':
+                        ai.ai_family = PF_INET6;
+                        break;
+                default:
+                        usage();
+                        exit(1);
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        if (argc != 2){
+                usage();
+                exit(1);
+        }
+
+        p = *argv[0] ? argv[0] : NULL;
+        q = *argv[1] ? argv[1] : NULL;
+
+        print1("arg:", &ai, p ? p : "(empty)", q ? q : "(empty)");
+
+        error = getaddrinfo(p, q, &ai, &res);
+        if (error) {
+                printf("%s\n", gai_strerror(error));
+                exit(1);
+        }
+
+        i = 1;
+        do {
+                snprintf(nbuf, sizeof(nbuf), "ai%d:", i);
+                print1(nbuf, res, NULL, NULL);
+
+                i++;
+        } while ((res = res->ai_next) != NULL);
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/getaddrinfo/testsuite.sh b/src/regress/lib/libc/getaddrinfo/testsuite.sh
new file mode 100644
index 0000000000..1e4e524054
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/testsuite.sh
@@ -0,0 +1,89 @@
+#       $OpenBSD: testsuite.sh,v 1.1 2002/07/05 15:54:30 itojun Exp $
+#       $NetBSD: testsuite.sh,v 1.3 2002/07/05 15:49:11 itojun Exp $
+
+#
+# Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, and 2002 WIDE Project.
+# 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.
+# 3. Neither the name of the project nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE PROJECT 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 PROJECT 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=./gaitest
+#TEST='./test -v'
+#IF=`ifconfig -a | grep -v '^   ' | sed -e 's/:.*//' | head -1 | awk '{print $1}'`
+
+echo '== basic ones'
+$TEST ::1 http
+$TEST 127.0.0.1 http
+$TEST localhost http
+$TEST ::1 tftp
+$TEST 127.0.0.1 tftp
+$TEST localhost tftp
+$TEST ::1 echo
+$TEST 127.0.0.1 echo
+$TEST localhost echo
+echo
+
+echo '== specific address family'
+$TEST -4 localhost http
+$TEST -6 localhost http
+echo
+
+echo '== empty hostname'
+$TEST '' http
+$TEST '' echo
+$TEST '' tftp
+$TEST '' 80
+$TEST -P '' http
+$TEST -P '' echo
+$TEST -P '' tftp
+$TEST -P '' 80
+$TEST -S '' 80
+$TEST -D '' 80
+echo
+
+echo '== empty servname'
+$TEST ::1 ''
+$TEST 127.0.0.1 ''
+$TEST localhost ''
+$TEST '' ''
+echo
+
+echo '== sock_raw'
+$TEST -R -p 0 localhost ''
+$TEST -R -p 59 localhost ''
+$TEST -R -p 59 localhost 80
+$TEST -R -p 59 localhost www
+$TEST -R -p 59 ::1 ''
+echo
+
+echo '== unsupported family'
+$TEST -f 99 localhost ''
+echo
+
+echo '== the following items are specified in jinmei scopeaddr format doc.'
+$TEST fe80::1%lo0 http
+#$TEST fe80::1%$IF http
+echo
diff --git a/src/regress/lib/libc/getcap/Makefile b/src/regress/lib/libc/getcap/Makefile
new file mode 100644
index 0000000000..7b7ae394ff
--- /dev/null
+++ b/src/regress/lib/libc/getcap/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.2 2009/06/09 18:16:40 phessler Exp $
+
+PROG=           getcaptest
+
+REGRESS_TARGETS=shortcap
+
+shortcap: getcaptest
+        ./getcaptest ${.CURDIR}/shortcap.in
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/getcap/getcaptest.c b/src/regress/lib/libc/getcap/getcaptest.c
new file mode 100644
index 0000000000..0f4464b6c5
--- /dev/null
+++ b/src/regress/lib/libc/getcap/getcaptest.c
@@ -0,0 +1,26 @@
+/*      $OpenBSD: getcaptest.c,v 1.1 2006/03/10 05:28:57 ray Exp $      */
+
+/*
+ * Written by Raymond Lai <ray@cyth.net>.
+ * Public domain.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int
+main(int argc, char *argv[])
+{
+        char *buf, *db_array[2];
+
+        if (argc != 2)
+                return (1);
+
+        db_array[0] = argv[1];
+        db_array[1] = NULL;
+
+        while (cgetnext(&buf, db_array) > 0)
+                puts(buf);
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/getcap/shortcap.in b/src/regress/lib/libc/getcap/shortcap.in
new file mode 100644
index 0000000000..573541ac97
--- /dev/null
+++ b/src/regress/lib/libc/getcap/shortcap.in
@@ -0,0 +1 @@
+0
diff --git a/src/regress/lib/libc/getopt_long/Makefile b/src/regress/lib/libc/getopt_long/Makefile
new file mode 100644
index 0000000000..13a187e190
--- /dev/null
+++ b/src/regress/lib/libc/getopt_long/Makefile
@@ -0,0 +1,32 @@
+#       $OpenBSD: Makefile,v 1.4 2002/12/08 19:25:08 millert Exp $
+
+NOMAN=
+PROG=getopt_long_test
+CLEANFILES+=test.out
+
+# test getopt_long and getopt_long_only
+run-regress-${PROG}: ${PROG}
+        @( test -n "$$POSIXLY_CORRECT" && unset POSIXLY_CORRECT; \
+          test -n "$$LONG_ONLY" && unset LONG_ONLY; \
+          ./${PROG} myfile --force -f infile -9 ; \
+          ./${PROG} onefile twofile --best -Williterate -i foo.in threefile ; \
+          ./${PROG} -1bfast - ; \
+          ./${PROG} --fast --drinking=guiness -i foo.in somefile ; \
+          export POSIXLY_CORRECT=1 ; \
+          ./${PROG} myfile --force -f infile -9 ; \
+          ./${PROG} onefile twofile --best -Williterate -i foo.in threefile ; \
+          ./${PROG} -1bfast - ; \
+          ./${PROG} --fast --drinking=guiness -i foo.in somefile ; \
+          unset POSIXLY_CORRECT ; export LONG_ONLY=1 ; \
+          ./${PROG} myfile -force -f infile -9 ; \
+          ./${PROG} onefile twofile -best -Williterate -i foo.in threefile ; \
+          ./${PROG} -1bfast - ; \
+          ./${PROG} --fast -drinking=guiness -i foo.in somefile ; \
+          export POSIXLY_CORRECT=1 ; \
+          ./${PROG} myfile -force -f infile -9 ; \
+          ./${PROG} onefile twofile -best -Williterate -i foo.in threefile ; \
+          ./${PROG} -1bfast - ; \
+          ./${PROG} --fast -drinking=guiness -i foo.in somefile ) >test.out 2>&1
+        cmp -s ${.OBJDIR}/test.out ${.CURDIR}/test.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/getopt_long/getopt_long_test.c b/src/regress/lib/libc/getopt_long/getopt_long_test.c
new file mode 100644
index 0000000000..9f6f603702
--- /dev/null
+++ b/src/regress/lib/libc/getopt_long/getopt_long_test.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F39502-99-1-0512.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+/*
+ * Simple getopt_long() and getopt_long_only() excerciser.
+ * ENVIRONMENT:
+ *      LONG_ONLY       : use getopt_long_only() (default is getopt_long())
+ *      POSIXLY_CORRECT : don't permute args
+ */
+
+int
+main(int argc, char **argv)
+{
+        int ch, idx, goggles;
+        int (*gl)(int, char * const *, const char *, const struct option *, int *);
+        struct option longopts[] = {
+                { "force", no_argument, 0, 0 },
+                { "fast", no_argument, 0, '1' },
+                { "best", no_argument, 0, '9' },
+                { "input", required_argument, 0, 'i' },
+                { "illiterate", no_argument, 0, 0 },
+                { "drinking", required_argument, &goggles, 42 },
+                { "help", no_argument, 0, 'h' },
+                { 0, 0, 0, 0 },
+        };
+
+        if (getenv("LONG_ONLY")) {
+                gl = getopt_long_only;
+                printf("getopt_long_only");
+        } else {
+                gl = getopt_long;
+                printf("getopt_long");
+        }
+        if (getenv("POSIXLY_CORRECT"))
+                printf(" (POSIXLY_CORRECT)");
+        printf(": ");
+        for (idx = 1; idx < argc; idx++)
+                printf("%s ", argv[idx]);
+        printf("\n");
+
+        goggles = 0;
+        for (;;) {
+                idx = -1;
+                ch = gl(argc, argv, "19bf:i:hW;-", longopts, &idx);
+                if (ch == -1)
+                        break;
+                switch (ch) {
+                case 0:
+                case '1':
+                case '9':
+                case 'h':
+                case 'b':
+                case '-':
+                        if (idx != -1) {
+                                if (goggles == 42)
+                                        printf("option %s, arg %s\n",
+                                            longopts[idx].name, optarg);
+                                else
+                                        printf("option %s\n",
+                                            longopts[idx].name);
+                        } else
+                                printf("option %c\n", ch);
+                        break;
+                case 'f':
+                case 'i':
+                        if (idx != -1)
+                                printf("option %s, arg %s\n",
+                                    longopts[idx].name, optarg);
+                        else
+                                printf("option %c, arg %s\n", ch, optarg);
+                        break;
+
+                case '?':
+                        break;
+
+                default:
+                        printf("unexpected return value: %c\n", ch);
+                        break;
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        if (argc > 0) {
+                printf("remaining ARGV: ");
+                while (argc--)
+                        printf("%s ", *argv++);
+                printf("\n");
+        }
+        printf("\n");
+
+        exit (0);
+}
diff --git a/src/regress/lib/libc/getopt_long/test.ok b/src/regress/lib/libc/getopt_long/test.ok
new file mode 100644
index 0000000000..9782087f40
--- /dev/null
+++ b/src/regress/lib/libc/getopt_long/test.ok
@@ -0,0 +1,84 @@
+getopt_long: myfile --force -f infile -9 
+option force
+option f, arg infile
+option 9
+remaining ARGV: myfile 
+
+getopt_long: onefile twofile --best -Williterate -i foo.in threefile 
+option best
+option illiterate
+option i, arg foo.in
+remaining ARGV: onefile twofile threefile 
+
+getopt_long: -1bfast - 
+option 1
+option b
+option f, arg ast
+option -
+
+getopt_long: --fast --drinking=guiness -i foo.in somefile 
+option fast
+option drinking, arg guiness
+option i, arg foo.in
+remaining ARGV: somefile 
+
+getopt_long (POSIXLY_CORRECT): myfile --force -f infile -9 
+remaining ARGV: myfile --force -f infile -9 
+
+getopt_long (POSIXLY_CORRECT): onefile twofile --best -Williterate -i foo.in threefile 
+remaining ARGV: onefile twofile --best -Williterate -i foo.in threefile 
+
+getopt_long (POSIXLY_CORRECT): -1bfast - 
+option 1
+option b
+option f, arg ast
+option -
+
+getopt_long (POSIXLY_CORRECT): --fast --drinking=guiness -i foo.in somefile 
+option fast
+option drinking, arg guiness
+option i, arg foo.in
+remaining ARGV: somefile 
+
+getopt_long_only: myfile -force -f infile -9 
+option force
+option f, arg infile
+option 9
+remaining ARGV: myfile 
+
+getopt_long_only: onefile twofile -best -Williterate -i foo.in threefile 
+option best
+option illiterate
+option i, arg foo.in
+remaining ARGV: onefile twofile threefile 
+
+getopt_long_only: -1bfast - 
+option 1
+option b
+option fast
+option -
+
+getopt_long_only: --fast -drinking=guiness -i foo.in somefile 
+option fast
+option drinking, arg guiness
+option i, arg foo.in
+remaining ARGV: somefile 
+
+getopt_long_only (POSIXLY_CORRECT): myfile -force -f infile -9 
+remaining ARGV: myfile -force -f infile -9 
+
+getopt_long_only (POSIXLY_CORRECT): onefile twofile -best -Williterate -i foo.in threefile 
+remaining ARGV: onefile twofile -best -Williterate -i foo.in threefile 
+
+getopt_long_only (POSIXLY_CORRECT): -1bfast - 
+option 1
+option b
+option fast
+option -
+
+getopt_long_only (POSIXLY_CORRECT): --fast -drinking=guiness -i foo.in somefile 
+option fast
+option drinking, arg guiness
+option i, arg foo.in
+remaining ARGV: somefile 
+
diff --git a/src/regress/lib/libc/glob/Makefile b/src/regress/lib/libc/glob/Makefile
new file mode 100644
index 0000000000..b3f9567833
--- /dev/null
+++ b/src/regress/lib/libc/glob/Makefile
@@ -0,0 +1,16 @@
+#       $OpenBSD: Makefile,v 1.4 2011/05/01 04:25:40 guenther Exp $
+
+PROG=   globtest
+
+run-regress-${PROG}:
+        mkdir -m 755 -p `sed 's@/[^/]*$$@@' ${.CURDIR}/files | sort -u`
+        umask 022; touch `cat ${.CURDIR}/files`
+        chmod 0755 `grep '/r[^/]*$$' ${.CURDIR}/files`
+        chmod 0444 `grep '/s[^/]*$$' ${.CURDIR}/files`
+        chmod 0711 `grep '/t[^/]*$$' ${.CURDIR}/files`
+        ./${PROG} ${.CURDIR}/${PROG}.in
+
+clean:
+        rm -rf fake ${PROG} ${OBJS} *.core
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/glob/files b/src/regress/lib/libc/glob/files
new file mode 100644
index 0000000000..c5e92aacd5
--- /dev/null
+++ b/src/regress/lib/libc/glob/files
@@ -0,0 +1,47 @@
+fake/bin/[
+fake/bin/cat
+fake/bin/chgrp
+fake/bin/chio
+fake/bin/chmod
+fake/bin/cksum
+fake/bin/cp
+fake/bin/cpio
+fake/bin/csh
+fake/bin/date
+fake/bin/dd
+fake/bin/df
+fake/bin/domainname
+fake/bin/echo
+fake/bin/ed
+fake/bin/eject
+fake/bin/expr
+fake/bin/hostname
+fake/bin/kill
+fake/bin/ksh
+fake/bin/ln
+fake/bin/ls
+fake/bin/md5
+fake/bin/mkdir
+fake/bin/mt
+fake/bin/mv
+fake/bin/pax
+fake/bin/ps
+fake/bin/pwd
+fake/bin/rcp
+fake/bin/rksh
+fake/bin/rm
+fake/bin/rmail
+fake/bin/rmd160
+fake/bin/rmdir
+fake/bin/sh
+fake/bin/sha1
+fake/bin/sha256
+fake/bin/sha384
+fake/bin/sha512
+fake/bin/sleep
+fake/bin/stty
+fake/bin/sum
+fake/bin/sync
+fake/bin/systrace
+fake/bin/tar
+fake/bin/test
diff --git a/src/regress/lib/libc/glob/globtest.c b/src/regress/lib/libc/glob/globtest.c
new file mode 100644
index 0000000000..325a7750f0
--- /dev/null
+++ b/src/regress/lib/libc/glob/globtest.c
@@ -0,0 +1,142 @@
+/*      $OpenBSD: globtest.c,v 1.3 2011/01/07 19:45:44 millert Exp $    */
+
+/*
+ * Public domain, 2008, Todd C. Miller <Todd.Miller@courtesan.com>
+ */
+
+#include <err.h>
+#include <glob.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAX_RESULTS     256
+
+struct gl_entry {
+        int flags;
+        int nresults;
+        char pattern[1024];
+        char *results[MAX_RESULTS];
+        mode_t modes[MAX_RESULTS];
+};
+
+int test_glob(struct gl_entry *);
+
+int
+main(int argc, char **argv)
+{
+        FILE *fp = stdin;
+        char *buf, *cp;
+        int errors = 0, lineno, mode;
+        struct gl_entry entry;
+        size_t len;
+
+        if (argc > 1) {
+                if ((fp = fopen(argv[1], "r")) == NULL)
+                        err(1, "%s", argv[1]);
+        }
+
+        /*
+         * Read in test file, which is formatted thusly:
+         *
+         * [pattern] <flags>
+         * result1 [mode]
+         * result2 [mode]
+         * result3 [mode]
+         * ...
+         *
+         */
+        lineno = 0;
+        memset(&entry, 0, sizeof(entry));
+        while ((buf = fgetln(fp, &len)) != NULL) {
+                lineno++;
+                if (buf[len - 1] != '\n')
+                        errx(1, "missing newline at EOF");
+                buf[--len] = '\0';
+                if (len == 0)
+                        continue; /* blank line */
+
+                if (buf[0] == '[') {
+                        /* check previous pattern */
+                        if (entry.pattern[0])
+                                errors += test_glob(&entry);
+
+                        /* start new entry */
+                        if ((cp = strrchr(buf + 1, ']')) == NULL)
+                                errx(1, "invalid entry on line %d", lineno);
+                        len = cp - buf - 1;
+                        if (len >= sizeof(entry.pattern))
+                                errx(1, "pattern too big on line %d", lineno);
+                        memcpy(entry.pattern, buf + 1, len);
+                        entry.pattern[len] = '\0';
+
+                        buf = cp + 2;
+                        if (*buf++ != '<')
+                                errx(1, "invalid entry on line %d", lineno);
+                        if ((cp = strchr(buf, '>')) == NULL)
+                                errx(1, "invalid entry on line %d", lineno);
+                        entry.flags = (int)strtol(buf, &cp, 0);
+                        if (*cp != '>' || entry.flags < 0 || entry.flags > 0x4000)
+                                errx(1, "invalid flags: %s", buf);
+                        entry.nresults = 0;
+                        continue;
+                }
+                if (!entry.pattern[0])
+                        errx(1, "missing entry on line %d", lineno);
+
+                if (entry.nresults + 1 > MAX_RESULTS) {
+                        errx(1, "too many results for %s, max %d",
+                            entry.pattern, MAX_RESULTS);
+                }
+                if ((cp = strchr(buf, ' ')) != NULL) {
+                        *cp++ = '\0';
+                        mode = strtol(cp, NULL, 8);
+                } else
+                        mode = -1;
+                entry.modes[entry.nresults] = (mode_t)mode;
+                entry.results[entry.nresults++] = strdup(buf);
+        }
+        if (entry.pattern[0])
+                errors += test_glob(&entry); /* test last pattern */
+        exit(errors);
+}
+
+int test_glob(struct gl_entry *entry)
+{
+        glob_t gl;
+        int i = 0;
+
+        if (glob(entry->pattern, entry->flags, NULL, &gl) != 0)
+                errx(1, "glob failed: %s", entry->pattern);
+
+        if (gl.gl_matchc != entry->nresults)
+                goto mismatch;
+
+        for (i = 0; i < gl.gl_matchc; i++) {
+                if (strcmp(gl.gl_pathv[i], entry->results[i]) != 0)
+                        goto mismatch;
+                if ((entry->flags & GLOB_KEEPSTAT) != 0) {
+                        if (entry->modes[i] == -1 ||
+                            gl.gl_statv[i] == NULL ||
+                            entry->modes[i] != gl.gl_statv[i]->st_mode)
+                        goto badmode;
+                }
+                free(entry->results[i]);
+        }
+        return (0);
+ badmode:
+        warnx("mismatch mode for pattern %s, flags 0x%x, file \"%s\" "
+            "(found %07o, expected %07o)", entry->pattern, entry->flags,
+            gl.gl_pathv[i], gl.gl_statv[i] ? gl.gl_statv[i]->st_mode : 0,
+            entry->modes[i]);
+        goto cleanup;
+ mismatch:
+        warnx("mismatch for pattern %s, flags 0x%x "
+            "(found \"%s\", expected \"%s\")", entry->pattern, entry->flags,
+            gl.gl_pathv[i], entry->results[i]);
+ cleanup:
+        while (i < gl.gl_matchc) {
+                free(entry->results[i++]);
+        }
+        return (1);
+}
diff --git a/src/regress/lib/libc/glob/globtest.in b/src/regress/lib/libc/glob/globtest.in
new file mode 100644
index 0000000000..2ae3b4dfb2
--- /dev/null
+++ b/src/regress/lib/libc/glob/globtest.in
@@ -0,0 +1,116 @@
+[fake/bin/[[:alpha:]]*] <0x0>
+fake/bin/cat
+fake/bin/chgrp
+fake/bin/chio
+fake/bin/chmod
+fake/bin/cksum
+fake/bin/cp
+fake/bin/cpio
+fake/bin/csh
+fake/bin/date
+fake/bin/dd
+fake/bin/df
+fake/bin/domainname
+fake/bin/echo
+fake/bin/ed
+fake/bin/eject
+fake/bin/expr
+fake/bin/hostname
+fake/bin/kill
+fake/bin/ksh
+fake/bin/ln
+fake/bin/ls
+fake/bin/md5
+fake/bin/mkdir
+fake/bin/mt
+fake/bin/mv
+fake/bin/pax
+fake/bin/ps
+fake/bin/pwd
+fake/bin/rcp
+fake/bin/rksh
+fake/bin/rm
+fake/bin/rmail
+fake/bin/rmd160
+fake/bin/rmdir
+fake/bin/sh
+fake/bin/sha1
+fake/bin/sha256
+fake/bin/sha384
+fake/bin/sha512
+fake/bin/sleep
+fake/bin/stty
+fake/bin/sum
+fake/bin/sync
+fake/bin/systrace
+fake/bin/tar
+fake/bin/test
+
+[fake/bin/[[:alpha:]]*] <0x4000>
+fake/bin/cat 0100644
+fake/bin/chgrp 0100644
+fake/bin/chio 0100644
+fake/bin/chmod 0100644
+fake/bin/cksum 0100644
+fake/bin/cp 0100644
+fake/bin/cpio 0100644
+fake/bin/csh 0100644
+fake/bin/date 0100644
+fake/bin/dd 0100644
+fake/bin/df 0100644
+fake/bin/domainname 0100644
+fake/bin/echo 0100644
+fake/bin/ed 0100644
+fake/bin/eject 0100644
+fake/bin/expr 0100644
+fake/bin/hostname 0100644
+fake/bin/kill 0100644
+fake/bin/ksh 0100644
+fake/bin/ln 0100644
+fake/bin/ls 0100644
+fake/bin/md5 0100644
+fake/bin/mkdir 0100644
+fake/bin/mt 0100644
+fake/bin/mv 0100644
+fake/bin/pax 0100644
+fake/bin/ps 0100644
+fake/bin/pwd 0100644
+fake/bin/rcp 0100755
+fake/bin/rksh 0100755
+fake/bin/rm 0100755
+fake/bin/rmail 0100755
+fake/bin/rmd160 0100755
+fake/bin/rmdir 0100755
+fake/bin/sh 0100444
+fake/bin/sha1 0100444
+fake/bin/sha256 0100444
+fake/bin/sha384 0100444
+fake/bin/sha512 0100444
+fake/bin/sleep 0100444
+fake/bin/stty 0100444
+fake/bin/sum 0100444
+fake/bin/sync 0100444
+fake/bin/systrace 0100444
+fake/bin/tar 0100711
+fake/bin/test 0100711
+
+[fake/bin/rm{,dir,ail}] <0x80>
+fake/bin/rm
+fake/bin/rmdir
+fake/bin/rmail
+
+[fake/bin/sha[[:digit:]]] <0x0>
+fake/bin/sha1
+
+[fake/bin/sha[[:digit:]]*] <0x0>
+fake/bin/sha1
+fake/bin/sha256
+fake/bin/sha384
+fake/bin/sha512
+
+[fake/bin/ca[a-z]] <0x0>
+fake/bin/cat
+
+[fake/b[a-z]*] <0x4000>
+fake/bin 0040755
+
diff --git a/src/regress/lib/libc/hsearch/Makefile b/src/regress/lib/libc/hsearch/Makefile
new file mode 100644
index 0000000000..cddc8ac0c4
--- /dev/null
+++ b/src/regress/lib/libc/hsearch/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2004/06/24 04:33:07 millert Exp $
+
+PROG=           hsearchtest
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/hsearch/hsearchtest.c b/src/regress/lib/libc/hsearch/hsearchtest.c
new file mode 100644
index 0000000000..8659ef7e77
--- /dev/null
+++ b/src/regress/lib/libc/hsearch/hsearchtest.c
@@ -0,0 +1,122 @@
+/*      $OpenBSD: hsearchtest.c,v 1.2 2009/10/27 23:59:32 deraadt Exp $ */
+/*      $NetBSD: hsearchtest.c,v 1.5 2003/07/26 19:38:46 salo Exp $     */
+
+/*
+ * Copyright (c) 2001 Christopher G. Demetriou
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *          This product includes software developed for the
+ *          NetBSD Project.  See http://www.NetBSD.org/ for
+ *          information about NetBSD.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
+ * 
+ * <<Id: LICENSE,v 1.2 2000/06/14 15:57:33 cgd Exp>>
+ */
+
+/*
+ * Test program for hsearch() et al.
+ */
+
+#include <search.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define TEST(e) ((e) ? (void)0 : testfail(__FILE__, __LINE__, #e))
+
+static void
+testfail(const char *file, unsigned long line, const char *expression)
+{
+
+        fprintf(stderr, "TEST FAILED: %s: file %s, line %ld\n",
+            expression, file, line);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        ENTRY e, *ep, *ep2;
+        int created_ok;
+        char ch[2];
+        int i;
+
+        created_ok = hcreate(16);
+        TEST(created_ok);
+
+        /* ch[1] should be constant from here on down. */
+        ch[1] = '\0';
+        
+        /* Basic insertions.  Check enough that there'll be collisions. */
+        for (i = 0; i < 26; i++) {
+                ch[0] = 'a' + i;
+                e.key = strdup(ch);     /* ptr to provided key is kept! */
+                TEST(e.key != NULL);
+                e.data = (void *)(long)i;
+                ep = hsearch(e, ENTER);
+                TEST(ep != NULL);
+                TEST(strcmp(ep->key, ch) == 0);
+                TEST((long)ep->data == i);
+        }
+
+        /* e.key should be constant from here on down. */
+        e.key = ch;
+
+        /* Basic lookups. */
+        for (i = 0; i < 26; i++) {
+                ch[0] = 'a' + i;
+                ep = hsearch(e, FIND);
+                TEST(ep != NULL);
+                TEST(strcmp(ep->key, ch) == 0);
+                TEST((long)ep->data == i);
+        }
+
+        /* Check duplicate entry.  Should _not_ overwrite existing data.  */
+        ch[0] = 'a';
+        e.data = (void *)(long)12345;
+        ep = hsearch(e, FIND);
+        TEST(ep != NULL);
+        TEST(strcmp(ep->key, ch) == 0);
+        TEST((long)ep->data == 0);
+
+        /* Check for something that's not there. */
+        ch[0] = 'A';
+        ep = hsearch(e, FIND);
+        TEST(ep == NULL);
+
+        /* Check two at once. */
+        ch[0] = 'a';
+        ep = hsearch(e, FIND);
+        ch[0] = 'b';
+        ep2 = hsearch(e, FIND);
+        TEST(ep != NULL);
+        TEST(strcmp(ep->key, "a") == 0 && (long)ep->data == 0);
+        TEST(ep2 != NULL);
+        TEST(strcmp(ep2->key, "b") == 0 && (long)ep2->data == 1);
+
+        hdestroy();
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/ieeefp/Makefile b/src/regress/lib/libc/ieeefp/Makefile
index 4e2e517b03..89ff51a2e7 100644
--- a/src/regress/lib/libc/ieeefp/Makefile
+++ b/src/regress/lib/libc/ieeefp/Makefile
@@ -1,12 +1,7 @@
-#       $NetBSD: Makefile,v 1.4 1995/10/03 21:59:36 phil Exp $
+#       $OpenBSD: Makefile,v 1.6 2004/01/15 18:53:23 miod Exp $
+#       $NetBSD: Makefile,v 1.5 1996/04/09 16:54:18 phil Exp $
 
-.if ${MACHINE} == "pc532"
-SUBDIR+= round
-.else
-SUBDIR+= except round
-.endif
-
-regress: _SUBDIRUSE
+SUBDIR+= except inf infinity round
 
 install:
 
diff --git a/src/regress/lib/libc/ieeefp/except/Makefile b/src/regress/lib/libc/ieeefp/except/Makefile
index 91f24f15f6..205331548f 100644
--- a/src/regress/lib/libc/ieeefp/except/Makefile
+++ b/src/regress/lib/libc/ieeefp/except/Makefile
@@ -1,12 +1,19 @@
-#       $NetBSD: Makefile,v 1.1 1995/04/26 00:27:25 jtc Exp $
+#       $OpenBSD: Makefile,v 1.5 2004/07/22 19:29:42 kettenis Exp $
 
-PROG=   except
-SRCS=   except.c
-NOMAN=
+PROG=except
 
-install:
+REGRESS_TARGETS+= fltdiv fltinv fltovf fltund
 
-regress: ${PROG}
-        ./${PROG}
+fltdiv: ${PROG}
+        ./${PROG} fltdiv
 
-.include <bsd.prog.mk>
+fltinv: ${PROG}
+        ./${PROG} fltinv
+
+fltovf: ${PROG}
+        ./${PROG} fltovf
+
+fltund: ${PROG}
+        ./${PROG} fltund
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/except/except.c b/src/regress/lib/libc/ieeefp/except/except.c
index 0ffdcdd468..cc3dcf8e44 100644
--- a/src/regress/lib/libc/ieeefp/except/except.c
+++ b/src/regress/lib/libc/ieeefp/except/except.c
@@ -1,21 +1,48 @@
+/*      $OpenBSD: except.c,v 1.12 2010/05/08 19:16:33 naddy Exp $       */
+
+#include <sys/types.h>
+#include <unistd.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <signal.h>
 #include <assert.h>
 #include <ieeefp.h>
 #include <float.h>
+#include <err.h>
 
-void sigfpe();
-volatile sig_atomic_t signal_cought;
+volatile sig_atomic_t signal_status;
 
-static volatile const double one  = 1.0;
-static volatile const double zero = 0.0;
-static volatile const double huge = DBL_MAX;
-static volatile const double tiny = DBL_MIN;
+volatile const double one  = 1.0;
+volatile const double zero = 0.0;
+volatile const double huge = DBL_MAX;
+volatile const double tiny = DBL_MIN;
 
-main()
+void
+sigfpe(int sig, siginfo_t *si, void *v)
 {
+        char buf[132];
+
+        if (si) {
+                snprintf(buf, sizeof(buf), "sigfpe: addr=%p, code=%d\n",
+                    si->si_addr, si->si_code);
+                write(1, buf, strlen(buf));
+        }
+        _exit(signal_status);
+}
+
+
+int
+main(int argc, char *argv[])
+{
+        struct sigaction sa;
         volatile double x;
 
+        if (argc != 2) {
+                fprintf(stderr, "usage: %s condition\n", argv[0]);
+                exit(1);
+        }
+
         /*
          * check to make sure that all exceptions are masked and 
          * that the accumulated exception status is clear.
@@ -23,65 +50,61 @@ main()
         assert(fpgetmask() == 0);
         assert(fpgetsticky() == 0);
 
-        /* set up signal handler */
-        signal (SIGFPE, sigfpe);
-        signal_cought = 0;
-
-        /* trip divide by zero */
-        x = one / zero;
-        assert (fpgetsticky() & FP_X_DZ);
-        assert (signal_cought == 0);
-        fpsetsticky(0);
-
-        /* trip invalid operation */
-        x = zero / zero;
-        assert (fpgetsticky() & FP_X_INV);
-        assert (signal_cought == 0);
-        fpsetsticky(0);
-
-        /* trip overflow */
-        x = huge * huge;
-        assert (fpgetsticky() & FP_X_OFL);
-        assert (signal_cought == 0);
-        fpsetsticky(0);
-
-        /* trip underflow */
-        x = tiny * tiny;
-        assert (fpgetsticky() & FP_X_UFL);
-        assert (signal_cought == 0);
-        fpsetsticky(0);
-
-#if 0
-        /* unmask and then trip divide by zero */
-        fpsetmask(FP_X_DZ);
-        x = one / zero;
-        assert (signal_cought == 1);
-        signal_cought = 0;
-
-        /* unmask and then trip invalid operation */
-        fpsetmask(FP_X_INV);
-        x = zero / zero;
-        assert (signal_cought == 1);
-        signal_cought = 0;
-
-        /* unmask and then trip overflow */
-        fpsetmask(FP_X_OFL);
-        x = huge * huge;
-        assert (signal_cought == 1);
-        signal_cought = 0;
-
-        /* unmask and then trip underflow */
-        fpsetmask(FP_X_UFL);
-        x = tiny * tiny;
-        assert (signal_cought == 1);
-        signal_cought = 0;
-#endif
-
-        exit(0);
-}
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_sigaction = sigfpe;
+        sa.sa_flags = SA_SIGINFO;
+        sigaction(SIGFPE, &sa, NULL);
+        signal_status = 1;
 
-void
-sigfpe()
-{
-        signal_cought = 1;
+        if (strcmp(argv[1], "fltdiv") == 0) {
+                /* trip divide by zero */
+                x = one / zero;
+                assert(fpgetsticky() & FP_X_DZ);
+                fpsetsticky(0);
+
+                /* and now unmask to get a signal */
+                signal_status = 0;
+                fpsetmask(FP_X_DZ);
+                x = one / zero;
+        } else if (strcmp(argv[1], "fltinv") == 0) {
+                /* trip invalid operation */
+                x = zero / zero;
+                assert(fpgetsticky() & FP_X_INV);
+                fpsetsticky(0);
+
+                /* and now unmask to get a signal */
+                signal_status = 0;
+                fpsetmask(FP_X_INV);
+                x = zero / zero;
+        } else if (strcmp(argv[1], "fltovf") == 0) {
+                /* trip overflow */
+                x = huge * huge;
+                assert(fpgetsticky() & FP_X_OFL);
+                fpsetsticky(0);
+
+                /* and now unmask to get a signal */
+                signal_status = 0;
+                fpsetmask(FP_X_OFL);
+                x = huge * huge;
+        } else if (strcmp(argv[1], "fltund") == 0) {
+                /* trip underflow */
+                x = tiny * tiny;
+                assert(fpgetsticky() & FP_X_UFL);
+                fpsetsticky(0);
+
+                /* and now unmask to get a signal */
+                signal_status = 0;
+                fpsetmask(FP_X_UFL);
+                x = tiny * tiny;
+        } else {
+                errx(1, "unrecognized condition %s", argv[1]);
+        }
+
+        /*
+         * attempt to trigger the exception on machines where
+         * floating-point exceptions are deferred.
+         */
+        x = one * one;
+
+        errx(1, "signal wasn't caught");
 }
diff --git a/src/regress/lib/libc/ieeefp/inf/Makefile b/src/regress/lib/libc/ieeefp/inf/Makefile
new file mode 100644
index 0000000000..b9a50e0ce6
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/inf/Makefile
@@ -0,0 +1,9 @@
+#       $OpenBSD: Makefile,v 1.1 2002/02/16 17:22:16 pvalchev Exp $
+
+PROG=   inf
+SRCS=   inf.c
+
+LDADD+= -lm
+DPADD+= ${LIBM}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/inf/inf.c b/src/regress/lib/libc/ieeefp/inf/inf.c
new file mode 100644
index 0000000000..a1956145a6
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/inf/inf.c
@@ -0,0 +1,16 @@
+/*      $OpenBSD: inf.c,v 1.3 2003/07/31 21:48:03 deraadt Exp $ */
+
+/*
+ * Peter Valchev <pvalchev@openbsd.org> Public Domain, 2002.
+ */
+
+#include <math.h>
+
+int
+main(int argc, char *argv[])
+{
+        if (isinf(HUGE_VAL))
+                return 0;
+
+        return 1;
+}
diff --git a/src/regress/lib/libc/ieeefp/infinity/Makefile b/src/regress/lib/libc/ieeefp/infinity/Makefile
new file mode 100644
index 0000000000..ac102d8a63
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/infinity/Makefile
@@ -0,0 +1,22 @@
+#       $OpenBSD: Makefile,v 1.2 2004/01/16 19:34:37 miod Exp $
+
+PROG=   infinity
+
+DPADD+= ${LIBM}
+LDADD+= -lm
+
+REGRESS_TARGETS+= add mult neg pumpkin
+
+add: ${PROG}
+        ./${PROG} -a
+
+mult: ${PROG}
+        ./${PROG} -m
+
+neg: ${PROG}
+        ./${PROG} -n
+
+pumpkin: ${PROG}
+        ./${PROG} -p
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/infinity/infinity.c b/src/regress/lib/libc/ieeefp/infinity/infinity.c
new file mode 100644
index 0000000000..3b1b71ec90
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/infinity/infinity.c
@@ -0,0 +1,77 @@
+/*      $OpenBSD: infinity.c,v 1.2 2004/01/16 19:34:37 miod Exp $       */
+/*
+ * Written by Miodrag Vallat, 2004 - Public Domain
+ * Inspired from Perl's t/op/arith test #134
+ */
+
+#include <math.h>
+#include <signal.h>
+#include <unistd.h>
+
+void
+sigfpe(int signum)
+{
+        /* looks like we don't handle fp overflow correctly... */
+        _exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        int opt;
+        double d, two;
+        int i;
+        char method = 'a';
+
+        while ((opt = getopt(argc, argv, "amnp")) != -1)
+                method = (char)opt;
+
+        signal(SIGFPE, sigfpe);
+
+        switch (method) {
+        case 'a':
+                /* try to produce +Inf through addition */
+                d = 1.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d + d;
+                }
+                /* result should be _positive_ infinity */
+                if (!isinf(d) || copysign(1.0, d) < 0.0)
+                        return (1);
+                break;
+        case 'm':
+                /* try to produce +Inf through multiplication */
+                d = 1.0;
+                two = 2.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d * two;
+                }
+                /* result should be _positive_ infinity */
+                if (!isinf(d) || copysign(1.0, d) < 0.0)
+                        return (1);
+                break;
+        case 'n':
+                /* try to produce -Inf through subtraction */
+                d = -1.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d + d;
+                }
+                /* result should be _negative_ infinity */
+                if (!isinf(d) || copysign(1.0, d) > 0.0)
+                        return (1);
+                break;
+        case 'p':
+                /* try to produce -Inf through multiplication */
+                d = -1.0;
+                two = 2.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d * two;
+                }
+                /* result should be _negative_ infinity */
+                if (!isinf(d) || copysign(1.0, d) > 0.0)
+                        return (1);
+                break;
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/ieeefp/round/Makefile b/src/regress/lib/libc/ieeefp/round/Makefile
index 571133436c..9ea6dd8c39 100644
--- a/src/regress/lib/libc/ieeefp/round/Makefile
+++ b/src/regress/lib/libc/ieeefp/round/Makefile
@@ -1,12 +1,5 @@
-#       $NetBSD: Makefile,v 1.1 1995/04/26 00:27:27 jtc Exp $
+#       $OpenBSD: Makefile,v 1.4 2002/02/18 11:25:34 art Exp $
 
 PROG=   round
-SRCS=   round.c
-NOMAN=
 
-install:
-
-regress: ${PROG}
-        ./${PROG}
-
-.include <bsd.prog.mk>
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/round/round.c b/src/regress/lib/libc/ieeefp/round/round.c
index b9fcd9771e..807941ea56 100644
--- a/src/regress/lib/libc/ieeefp/round/round.c
+++ b/src/regress/lib/libc/ieeefp/round/round.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: round.c,v 1.3 2003/07/31 21:48:03 deraadt Exp $       */
 /*      $NetBSD: round.c,v 1.1 1995/04/26 00:27:28 jtc Exp $    */
 
 /*
@@ -11,7 +12,7 @@
 #include <float.h>
 
 int
-main()
+main(int argc, char *argv[])
 {
         /*
          * This test would be better if it actually performed some
diff --git a/src/regress/lib/libc/locale/Makefile b/src/regress/lib/libc/locale/Makefile
new file mode 100644
index 0000000000..c182172ba2
--- /dev/null
+++ b/src/regress/lib/libc/locale/Makefile
@@ -0,0 +1,7 @@
+# $OpenBSD: Makefile,v 1.1 2005/08/11 21:57:02 espie Exp $
+
+SUBDIR+= check_isw
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/locale/check_isw/Makefile b/src/regress/lib/libc/locale/check_isw/Makefile
new file mode 100644
index 0000000000..0885968fd1
--- /dev/null
+++ b/src/regress/lib/libc/locale/check_isw/Makefile
@@ -0,0 +1,9 @@
+#       $OpenBSD: Makefile,v 1.1 2005/08/11 21:57:02 espie Exp $
+
+NOMAN=
+PROG=check_isw
+
+run-regress-check_isw: ${PROG}
+        ./${PROG} >/dev/null
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/locale/check_isw/check_isw.c b/src/regress/lib/libc/locale/check_isw/check_isw.c
new file mode 100644
index 0000000000..9386267f61
--- /dev/null
+++ b/src/regress/lib/libc/locale/check_isw/check_isw.c
@@ -0,0 +1,147 @@
+/* $OpenBSD: check_isw.c,v 1.1 2005/08/11 21:57:02 espie Exp $ */
+/*
+ * Copyright (c) 2005 Marc Espie <espie@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* This checks consistency of the isw* functions with the default <ctype>
+ * functions.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <wchar.h>
+#include <wctype.h>
+
+int bad = 0;
+
+void
+check_bool(int v1, int v2, char msg)
+{
+        if (!v1 != !v2) {
+                printf("%c", msg);
+                bad++;
+        }
+}
+
+void 
+check_value(int v1, int v2, char msg)
+{
+        if (v1 != v2) {
+                printf("%c", msg);
+                bad++;
+        }
+}
+
+void
+test1()
+{
+        int i;
+
+        for (i = 0; i < 256; i++) {
+                printf(" %02x: ", i);
+                check_bool(isalnum(i), iswalnum(i), '1');
+                check_bool(isalpha(i), iswalpha(i), '2');
+                check_bool(isblank(i), iswblank(i), '3');
+                check_bool(iscntrl(i), iswcntrl(i), '4');
+                check_bool(isdigit(i), iswdigit(i), '5');
+                check_bool(isgraph(i), iswgraph(i), '6');
+                check_bool(islower(i), iswlower(i), '6');
+                check_bool(isprint(i), iswprint(i), '7');
+                check_bool(ispunct(i), iswpunct(i), '8');
+                check_bool(isspace(i), iswspace(i), '9');
+                check_bool(isupper(i), iswupper(i), 'a');
+                check_bool(isxdigit(i), iswxdigit(i), 'b');
+                check_value(tolower(i), towlower(i), 'c');
+                check_value(toupper(i), towupper(i), 'd');
+                if (i % 8 == 7)
+                        printf("\n");
+        }
+        printf("%\n");
+}
+
+void
+test2()
+{
+        unsigned char *s;
+        unsigned char *buf;
+        int i, j;
+        size_t n;
+        wchar_t c, d;
+        mbstate_t state;
+
+        s = malloc(256);
+        if (!s) {
+                bad++;
+                return;
+        }
+        buf = malloc(MB_CUR_MAX);
+        if (!buf) {
+                bad++;
+                free(s);
+                return;
+        }
+        for (i = 0; i < 256; i++)
+                s[i] = i+1;
+
+        j = 0;
+        mbrtowc(NULL, NULL, 1, &state);
+        printf(" %02x: ", 0);
+
+        while ((n = mbrtowc(&c, s+j, 256-j, &state)) == 1) {
+                printf(" %02x: ", s[j]);
+                check_bool(isalnum(s[j]), iswalnum(c), '1');
+                check_bool(isalpha(s[j]), iswalpha(c), '2');
+                check_bool(isblank(s[j]), iswblank(c), '3');
+                check_bool(iscntrl(s[j]), iswcntrl(c), '4');
+                check_bool(isdigit(s[j]), iswdigit(c), '5');
+                check_bool(isgraph(s[j]), iswgraph(c), '6');
+                check_bool(islower(s[j]), iswlower(c), '6');
+                check_bool(isprint(s[j]), iswprint(c), '7');
+                check_bool(ispunct(s[j]), iswpunct(c), '8');
+                check_bool(isspace(s[j]), iswspace(c), '9');
+                check_bool(isupper(s[j]), iswupper(c), 'a');
+                check_bool(isxdigit(s[j]), iswxdigit(c), 'b');
+                d = towlower(c);
+                if (wctomb(buf, d) == 1) {      
+                        check_value(tolower(s[j]), buf[0], 'c');
+                } else {
+                        bad++;
+                }
+                d = towupper(c);
+                if (wctomb(buf, d) == 1) {      
+                        check_value(toupper(s[j]), buf[0], 'c');
+                } else {
+                        bad++;
+                }
+                if (s[j] % 8 == 7)
+                        printf("\n");
+                j++;
+        }
+        if (n != 0 || j != 255) {
+                bad++;
+        }
+        free(s);
+        free(buf);
+}
+
+
+int
+main()
+{
+        test1();
+        test2();
+        return bad !=0;
+}
diff --git a/src/regress/lib/libc/longjmp/Makefile b/src/regress/lib/libc/longjmp/Makefile
new file mode 100644
index 0000000000..825e0f86d9
--- /dev/null
+++ b/src/regress/lib/libc/longjmp/Makefile
@@ -0,0 +1,13 @@
+#       $OpenBSD: Makefile,v 1.4 2002/09/02 20:01:43 avsm Exp $
+PROG=   longjmp
+
+do-longjmp: ${PROG}
+        ./longjmp
+
+do-_longjmp: ${PROG}
+        ./longjmp -_
+
+REGRESS_TARGETS=do-longjmp do-_longjmp
+.PHONY: ${REGRESS_TARGETS}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/longjmp/longjmp.c b/src/regress/lib/libc/longjmp/longjmp.c
new file mode 100644
index 0000000000..7dea5bd97c
--- /dev/null
+++ b/src/regress/lib/libc/longjmp/longjmp.c
@@ -0,0 +1,71 @@
+/*      $OpenBSD: longjmp.c,v 1.4 2002/02/18 11:27:45 art Exp $ */
+/*
+ *      Artur Grabowski <art@openbsd.org>, 2002 Public Domain.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <setjmp.h>
+#include <err.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+
+jmp_buf buf;
+
+/*
+ * When longjmp is passed the incorrect arg (0), it should translate it into
+ * something better.
+ *
+ * The rlimit is here in case we start spinning.
+ */
+int
+main(int argc, char **argv)
+{
+        struct rlimit rl;
+        volatile int i, expect;
+        int (*sj)(jmp_buf);
+        void (*lj)(jmp_buf, int);
+        int ch;
+        extern char *__progname;
+
+        sj = setjmp;
+        lj = longjmp;
+
+        while ((ch = getopt(argc, argv, "_")) != -1) {
+                switch (ch) {
+                case '_':
+                        sj = _setjmp;
+                        lj = _longjmp;
+                        break;
+                default:
+                        fprintf(stderr, "Usage: %s [-_]\n", __progname);
+                        exit(1);
+                }
+        }
+
+        rl.rlim_cur = 2;
+        rl.rlim_max = 2;
+        if (setrlimit(RLIMIT_CPU, &rl) < 0)
+                err(1, "setrlimit");
+
+        expect = 0;
+        i = (*sj)(buf);
+        if (i == 0 && expect != 0)
+                errx(1, "setjmp returns 0 on longjmp(.., 0)");
+        if (expect == 0) {
+                expect = -1;
+                (*lj)(buf, 0);
+        }
+
+        expect = 0;
+        i = (*sj)(buf);
+        if (i != expect)
+                errx(1, "bad return from setjmp %d/%d", expect, i);
+        if (expect < 1000)
+                (*lj)(buf, expect += 2);
+
+        return 0;
+}
diff --git a/src/regress/lib/libc/malloc/Makefile b/src/regress/lib/libc/malloc/Makefile
new file mode 100644
index 0000000000..7c919d1bc2
--- /dev/null
+++ b/src/regress/lib/libc/malloc/Makefile
@@ -0,0 +1,7 @@
+#       $OpenBSD: Makefile,v 1.5 2006/04/18 19:04:39 otto Exp $
+
+SUBDIR+= malloc0test malloc_errno malloc_ulimit1 malloc_ulimit2
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/malloc/malloc0test/Makefile b/src/regress/lib/libc/malloc/malloc0test/Makefile
new file mode 100644
index 0000000000..8ed8163a79
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc0test/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/07/15 10:09:37 otto Exp $
+
+PROG=   malloc0test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc0test/malloc0test.c b/src/regress/lib/libc/malloc/malloc0test/malloc0test.c
new file mode 100644
index 0000000000..06ff0996ee
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc0test/malloc0test.c
@@ -0,0 +1,120 @@
+/*      $OpenBSD: malloc0test.c,v 1.5 2008/04/13 00:22:17 djm Exp $     */
+/*
+ * Public domain.  2001, Theo de Raadt
+ */
+#include <sys/types.h>
+#include <sys/signal.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include <limits.h>
+#include <errno.h>
+
+volatile sig_atomic_t got;
+jmp_buf jmp;
+
+static void
+catch(int signo)
+{
+        got++;
+        longjmp(jmp, 1);
+}
+
+static int
+test(char *p, int size)
+{
+        signal(SIGSEGV, catch);
+        got = 0;
+        if (setjmp(jmp) == 0)
+                *p = 0;
+        if (setjmp(jmp) == 0)
+                *(p+size-1) = 0;
+        return (got);
+}
+
+char *prot_table[] = {
+        "unprotected",
+        "fuckup",
+        "protected"
+};
+
+#define SIZE    10
+
+/*
+ * Do random memory allocations.
+ *
+ * For each one, ensure that it is at least 16 bytes in size (that
+ * being what our current malloc returns for the minsize of an
+ * object, alignment wise);
+ *
+ * For zero-byte allocations, check that they are still aligned.
+ *
+ * For each object, ensure that they are correctly protected or not
+ * protected.
+ *
+ * Does not regress test malloc + free combinations ... it should.
+ */
+int
+main(int argc, char *argv[])
+{
+        caddr_t blob;
+        int size, tsize;
+        int prot;
+        int rval = 0, fuckup = 0;
+        long limit = 200000, count;
+        int ch, silent = 0;
+        char *ep;
+        extern char *__progname;
+
+        while ((ch = getopt(argc, argv, "sn:")) != -1) {
+                switch (ch) {
+                case 's':
+                        silent = 1;
+                        break;
+                case 'n':
+                        errno = 0;
+                        limit = strtol(optarg, &ep, 10);
+                        if (optarg[0] == '\0' || *ep != '\0' ||
+                            (errno == ERANGE &&
+                             (limit == LONG_MAX || limit == LONG_MIN)))
+                                goto usage;
+                        break;
+                default:
+usage:
+                        fprintf(stderr, "Usage: %s [-s][-n <count>]\n",
+                            __progname);
+                        exit(1);
+                }
+        }
+
+        if (limit == 0)
+                limit = LONG_MAX;
+
+        for (count = 0; count < limit; count++) {
+                size = arc4random_uniform(SIZE);
+                blob = malloc(size);
+                if (blob == NULL) {
+                        fprintf(stderr, "success: out of memory\n");
+                        exit(rval);
+                }
+
+                tsize = size == 0 ? 16 : size;
+                fuckup = 0;
+                prot = test(blob, tsize);
+
+                if (size == 0 && prot < 2)
+                        fuckup = 1;
+
+                if (fuckup) {
+                        printf("%8p %6d %20s %10s\n", blob, size,
+                            prot_table[prot], fuckup ? "fuckup" : "");
+                        rval = 1;
+                }
+
+                if (!silent && count % 100000 == 0 && count != 0)
+                        fprintf(stderr, "count = %ld\n", count);
+        }
+
+        return rval;
+}
diff --git a/src/regress/lib/libc/malloc/malloc_errno/Makefile b/src/regress/lib/libc/malloc/malloc_errno/Makefile
new file mode 100644
index 0000000000..73ebe37491
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_errno/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/07/15 10:06:31 otto Exp $
+
+PROG=   malloc_errno
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c b/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c
new file mode 100644
index 0000000000..896ea3c900
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c
@@ -0,0 +1,46 @@
+/*      $OpenBSD: malloc_errno.c,v 1.4 2003/12/25 18:49:57 miod Exp $   */
+/*
+ * Public domain.  2003, Otto Moerbeek
+ */
+#include <err.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static void
+testerrno(size_t sz)
+{
+        void *p;
+
+        errno = -1;
+        p = malloc(sz);
+
+        if (p == NULL && errno != ENOMEM)
+                errx(1, "fail: %lx %p %d", (unsigned long)sz, p, errno);
+
+        /* if alloc succeeded, test if errno did not change */
+        if (p != NULL && errno != -1) 
+                errx(1, "fail: %lx %p %d", (unsigned long)sz, p, errno);
+
+        free(p);
+}
+
+/*
+ * Provide some (silly) arguments to malloc(), and check if ERRNO is set
+ * correctly.
+ */
+int
+main(int argc, char *argv[])
+{
+        size_t i;
+
+        testerrno(1);
+        testerrno(100000);
+        testerrno(-1);
+        testerrno(-1000);
+        testerrno(-10000);
+        testerrno(-10000000);
+        for (i = 0; i < 0x10; i++)
+                testerrno(i * 0x10000000);
+        return 0;
+}
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile b/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile
new file mode 100644
index 0000000000..46ced27a98
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/04/18 19:03:30 otto Exp $
+
+PROG=   malloc_ulimit1
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c b/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c
new file mode 100644
index 0000000000..99e805e8e1
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c
@@ -0,0 +1,44 @@
+/*      $OpenBSD: malloc_ulimit1.c,v 1.2 2006/05/16 05:47:13 otto Exp $ */
+
+/* Public Domain, 2006, Otto Moerbeek <otto@drijf.net> */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <err.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/*
+ * This code tries to trigger the case present in -current as of April
+ * 2006) where the allocation of the region itself succeeds, but the
+ * page dir entry pages fails.
+ * This in turn trips a "hole in directories" error.
+ * Having a large (512M) ulimit -m helps a lot in triggering the 
+ * problem. Note that you may need to run this test multiple times to
+ * see the error.
+*/
+
+#define STARTI  1300
+#define FACTOR  1024
+
+main()
+{
+        struct rlimit lim;
+        size_t sz;
+        int i;
+        void *p;
+
+        if (getrlimit(RLIMIT_DATA, &lim) == -1)
+                err(1, "getrlimit");
+
+        sz = lim.rlim_cur / FACTOR;
+
+        for (i = STARTI; i >= 0; i--) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                free(p);
+                free(malloc(4096));
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile b/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile
new file mode 100644
index 0000000000..bc83666415
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/04/18 19:04:03 otto Exp $
+
+PROG=   malloc_ulimit2
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c b/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c
new file mode 100644
index 0000000000..ca8e8f438a
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c
@@ -0,0 +1,42 @@
+/*      $OpenBSD: malloc_ulimit2.c,v 1.2 2006/05/16 05:47:13 otto Exp $ */
+
+/* Public Domain, 2006, Otto Moerbeek <otto@drijf.net> */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <err.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define FACTOR  1024
+
+main()
+{
+        struct rlimit lim;
+        size_t sz;
+        int i;
+        void *p;
+
+        if (getrlimit(RLIMIT_DATA, &lim) == -1)
+                err(1, "getrlimit");
+
+        sz = lim.rlim_cur / FACTOR;
+
+        for (i = 0; ; i++) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                if (p != NULL) {
+                        free(p);
+                        break;
+                }
+        }
+        i += 10;
+        for (; i >= 0; i--) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                free(p);
+                free(malloc(4096));
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/mkstemp/Makefile b/src/regress/lib/libc/mkstemp/Makefile
new file mode 100644
index 0000000000..dc7eb281a9
--- /dev/null
+++ b/src/regress/lib/libc/mkstemp/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.1 2010/02/11 07:35:38 guenther Exp $
+
+PROG=mkstemp_test
+CLEANFILES+= ; rm -rf output
+
+O = output
+
+# The ktrace/kdump/perl combo verifies that all open() calls that
+# were passed O_CREAT were also passed O_EXCL
+run-regress-${PROG}: ${PROG}
+        mkdir -p $O && cd $O && ktrace ../${PROG}
+        cd $O && kdump | perl -mFcntl -nl \
+                -e '/ open\([^,]*,([^,]+)/      or next;'       \
+                -e '$$f = oct($$1);'                            \
+                -e 'if ($$f & O_CREAT && !($$f & O_EXCL)) {'    \
+                -e '    print "FAIL"; exit 1'                   \
+                -e '}'
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/mkstemp/mkstemp_test.c b/src/regress/lib/libc/mkstemp/mkstemp_test.c
new file mode 100644
index 0000000000..fd133d8368
--- /dev/null
+++ b/src/regress/lib/libc/mkstemp/mkstemp_test.c
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2010  Philip Guenther <guenther@openbsd.org>
+ *
+ * Public domain.
+ *
+ * Verify that mkstemp() and mkstemps() doesn't overrun or underrun
+ * the template buffer and that it can generate names that don't
+ * contain any X's
+ */
+
+#include <sys/param.h>
+
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#define MAX_TEMPLATE_LEN        10
+#define MAX_TRIES               100
+
+#define SUFFIX  ".suff"
+#define SLEN    (sizeof SUFFIX - 1)
+
+long pg;
+
+/*
+ * verify that a path generated by mkstemp() or mkstemp() looks like a
+ * reasonable expansion of the template and matches the fd.  Returns true
+ * if all the X's were replaced with non-X's
+ */
+int
+check(int fd, char const *path, char const *prefix, size_t plen,
+    char const *suffix, size_t slen, int tlen)
+{
+        struct stat sb, fsb;
+        char const *p;
+
+        if (fd < 0)
+                err(1, "mkstemp");
+        if (stat(path, &sb))
+                err(1, "stat(%s)", path);
+        if (fstat(fd, &fsb))
+                err(1, "fstat(%d==%s)", fd, path);
+        if (sb.st_dev != fsb.st_dev || sb.st_ino != fsb.st_ino)
+                errx(1, "stat mismatch");
+        close(fd);
+        if (memcmp(path, prefix, plen) != 0)
+                errx(1, "prefix changed!  %s vs %s", prefix, path);
+        if (memcmp(path + plen + tlen, suffix, slen + 1) != 0)
+                errx(1, "suffix changed!  %s vs %s", suffix, path);
+        for (p = path + plen; p < path + plen + tlen; p++)
+                if (*p == '\0')
+                        errx(1, "unexpected truncation");
+                else if (*p == 'X')
+                        return 0;
+        return 1;
+}
+
+
+void
+try_mkstemp(char *p, char const *prefix, int len)
+{
+        char *q;
+        size_t plen = strlen(prefix);
+        int tries, fd;
+
+        for (tries = 0; tries < MAX_TRIES; tries++) {
+                memcpy(p, prefix, plen);
+                memset(p + plen, 'X', len);
+                p[plen + len] = '\0';
+                fd = mkstemp(p);
+                if (check(fd, p, prefix, plen, "", 0, len))
+                        return;
+        }
+        errx(1, "exceeded MAX_TRIES");
+}
+
+void
+try_mkstemps(char *p, char const *prefix, int len, char const *suffix)
+{
+        char *q;
+        size_t plen = strlen(prefix);
+        size_t slen = strlen(suffix);
+        int tries, fd;
+
+        for (tries = 0; tries < MAX_TRIES; tries++) {
+                memcpy(p, prefix, plen);
+                memset(p + plen, 'X', len);
+                memcpy(p + plen + len, suffix, slen + 1);
+                fd = mkstemps(p, slen);
+                if (check(fd, p, prefix, plen, suffix, slen, len))
+                        return;
+        }
+        errx(1, "exceeded MAX_TRIES");
+}
+
+int
+main(void)
+{
+        struct stat sb, fsb;
+        char cwd[MAXPATHLEN + 1];
+        char *p;
+        size_t clen;
+        int i;
+
+        pg = sysconf(_SC_PAGESIZE);
+        if (getcwd(cwd, sizeof cwd - 1) == NULL)
+                err(1, "getcwd");
+        clen = strlen(cwd);
+        cwd[clen++] = '/';
+        cwd[clen] = '\0';
+        p = mmap(NULL, pg * 3, PROT_READ | PROT_WRITE, MAP_ANON, -1, 0);
+        if (p == NULL)
+                err(1, "mmap");
+        if (mprotect(p, pg, PROT_NONE) || mprotect(p + pg * 2, pg, PROT_NONE))
+                err(1, "mprotect");
+        p += pg;
+
+        i = MAX_TEMPLATE_LEN + 1;
+        while (i-- > 1) {
+                /* try first at the start of a page, no prefix */
+                try_mkstemp(p, "", i);
+                /* now at the end of the page, no prefix */
+                try_mkstemp(p + pg - i - 1, "", i);
+                /* start of the page, prefixed with the cwd */
+                try_mkstemp(p, cwd, i);
+                /* how about at the end of the page, prefixed with cwd? */
+                try_mkstemp(p + pg - clen - i - 1, cwd, i);
+
+                /* again, with mkstemps() and an empty suffix */
+                /* try first at the start of a page, no prefix */
+                try_mkstemps(p, "", i, "");
+                /* now at the end of the page, no prefix */
+                try_mkstemps(p + pg - i - 1, "", i, "");
+                /* start of the page, prefixed with the cwd */
+                try_mkstemps(p, cwd, i, "");
+                /* how about at the end of the page, prefixed with cwd? */
+                try_mkstemps(p + pg - clen - i - 1, cwd, i, "");
+
+                /* mkstemps() and a non-empty suffix */
+                /* try first at the start of a page, no prefix */
+                try_mkstemps(p, "", i, SUFFIX);
+                /* now at the end of the page, no prefix */
+                try_mkstemps(p + pg - i - SLEN - 1, "", i, SUFFIX);
+                /* start of the page, prefixed with the cwd */
+                try_mkstemps(p, cwd, i, SUFFIX);
+                /* how about at the end of the page, prefixed with cwd? */
+                try_mkstemps(p + pg - clen - i - SLEN - 1, cwd, i, SUFFIX);
+
+        }
+
+        return 0;
+}
diff --git a/src/regress/lib/libc/netdb/Makefile b/src/regress/lib/libc/netdb/Makefile
new file mode 100644
index 0000000000..8254607227
--- /dev/null
+++ b/src/regress/lib/libc/netdb/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2004/10/25 15:10:36 otto Exp $
+
+PROG=   netdb
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/netdb/netdb.c b/src/regress/lib/libc/netdb/netdb.c
new file mode 100644
index 0000000000..fabb3ee4e1
--- /dev/null
+++ b/src/regress/lib/libc/netdb/netdb.c
@@ -0,0 +1,183 @@
+/*      $OpenBSD: netdb.c,v 1.2 2011/05/01 04:27:07 guenther Exp $      */
+
+/*
+ * Public domain, 2004, Otto Moerbeek <otto@drijf.net>
+ */
+
+#include <err.h>
+#include <netdb.h>
+#include <stdarg.h>
+#include <string.h>
+
+int ret = 0;
+
+void
+checkp(int n, struct protoent *p, int proto, const char *name, ...)
+{
+        va_list va;
+        char *a;
+        int i;
+
+        if (p == NULL) {
+                warnx("%d proto struct is NULL", n);
+                ret = 1;
+                return;
+        }
+        if (p->p_proto != proto) {
+                warnx("%d proto num mismatch %d %d", n, p->p_proto, proto);
+                ret = 1;
+        }
+        if (strcmp(p->p_name, name) != 0) {
+                warnx("%d proto name mismatch %s %s", n, p->p_name, name);
+                ret = 1;
+        }
+        va_start(va, name);
+        a = va_arg(va, char *);
+        i = 0;
+        while (a != NULL) {
+                if (strcmp(p->p_aliases[i], a) != 0) {
+                        warnx("%d proto alias mismatch %s %s", n,
+                            p->p_aliases[i], a);
+                        ret = 1;
+                }
+                i++;
+                a = va_arg(va, char *);
+        }
+        if (p->p_aliases[i] != NULL) {
+                        warnx("%d proto alias list does not end with NULL", n);
+                        ret = 1;
+        }
+        va_end(va);
+}
+
+
+void
+checks(int n, struct servent *s, int port, const char *proto,
+    const char *name, ...)
+{
+        va_list va;
+        char *a;
+        int i;
+
+        if (s == NULL) {
+                warnx("%d serv struct is NULL", n);
+                ret = 1;
+                return;
+        }
+        if (s->s_port != ntohs(port)) {
+                warnx("%d port num mismatch %d %d", n, s->s_port, port);        
+                ret = 1;
+        }
+        if (strcmp(s->s_name, name) != 0) {
+                warnx("%d serv name mismatch %s %s", n, s->s_name, name);
+                ret = 1;
+        }
+        if (strcmp(s->s_proto, proto) != 0) {
+                warnx("%d serv proto mismatch %s %s", n, s->s_proto, proto);
+                ret = 1;
+        }
+        va_start(va, name);
+        a = va_arg(va, char *);
+        i = 0;
+        while (a != NULL) {
+                if (strcmp(s->s_aliases[i], a) != 0) {
+                        warnx("%d serv alias mismatch %s %s", n,
+                            s->s_aliases[i], a);
+                        ret = 1;
+                }
+                i++;
+                a = va_arg(va, char *);
+        }
+        if (s->s_aliases[i] != NULL) {
+                        warnx("%d serv alias list does not end with NULL", n);
+                        ret = 1;
+        }
+        va_end(va);
+}
+
+int
+main()
+{
+        struct protoent *p;
+        struct protoent protoent;
+        struct protoent_data protoent_data;
+        struct servent *s;
+        struct servent servent;
+        struct servent_data servent_data;
+        int r;
+
+        p = getprotobynumber(35);
+        checkp(1, p, 35, "idpr", "IDPR", (char *)NULL);
+
+        p = getprotobyname("igp");
+        checkp(2, p, 9, "igp", "IGP", (char *) NULL);
+
+        p = getprotobyname("RDP");
+        checkp(3, p, 27, "rdp", "RDP", (char *) NULL);
+
+        p = getprotobyname("vrrp");
+        checkp(4, p, 112, "carp", "CARP", "vrrp", (char *) NULL);
+
+        p = getprotobyname("nonexistent");
+        if (p != NULL)
+                err(1, "nonexistent proto found");
+
+        memset(&protoent_data, 0, sizeof(protoent_data));
+        r = getprotobynumber_r(35, &protoent, &protoent_data);
+        if (r != 0) 
+                err(1, "proto not found");
+
+        checkp(5, &protoent, 35, "idpr", "IDPR", (char *)NULL);
+
+        r = getprotobyname_r("vrrp", &protoent, &protoent_data);
+        if (r != 0) 
+                err(1, "proto not found");
+        checkp(6, &protoent, 112, "carp", "CARP", "vrrp", (char *) NULL);
+
+        r = getprotobyname_r("nonexistent", &protoent, &protoent_data);
+        if (r != -1)
+                err(1, "nonexistent proto found");
+
+        r = getprotobyname_r("", &protoent, &protoent_data);
+        if (r != -1)
+                err(1, "nonexistent proto found");
+
+
+        r = getprotobynumber_r(256, &protoent, &protoent_data);
+        if (r != -1)
+                err(1, "nonexistent proto found");
+
+        s = getservbyname("zip", NULL);
+        checks(7, s, 6, "ddp", "zip", (char *)NULL);
+
+        s = getservbyname("nicname", "tcp");
+        checks(8, s, 43, "tcp", "whois", "nicname", (char *)NULL);
+
+        s = getservbyport(htons(42), "tcp");
+        checks(9, s, 42, "tcp", "nameserver", "name", (char *)NULL);
+
+        memset(&servent_data, 0, sizeof(servent_data));
+        r = getservbyname_r("zip", "ddp", &servent, &servent_data);
+        if (r != 0) 
+                err(1, "servent not found");
+        checks(10, &servent, 6, "ddp", "zip", (char *)NULL);
+
+        r = getservbyport_r(htons(520), NULL, &servent, &servent_data);
+        if (r != 0) 
+                err(1, "servent not found");
+        checks(11, &servent, 520, "udp", "route", "router", "routed", (char *)NULL);
+
+        r = getservbyname_r("nonexistent", NULL, &servent, &servent_data);
+        if (r != -1) 
+                err(1, "nonexiststent servent found");
+
+        r = getservbyport_r(htons(50000), NULL, &servent, &servent_data);
+        if (r != -1) 
+                err(1, "nonexistent servent found");
+
+        r = getservbyport_r(htons(520), "tcp", &servent, &servent_data);
+        if (r != -1) 
+                err(1, "nonexistent servent found");
+
+        return ret;
+}
diff --git a/src/regress/lib/libc/orientation/Makefile b/src/regress/lib/libc/orientation/Makefile
new file mode 100644
index 0000000000..5c73702abe
--- /dev/null
+++ b/src/regress/lib/libc/orientation/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.2 2010/06/29 16:20:28 guenther Exp $
+
+NOMAN=
+PROG=orientation_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+
+run-regress-${PROG}: ${PROG}
+        ./${PROG}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/orientation/orientation_test.c b/src/regress/lib/libc/orientation/orientation_test.c
new file mode 100644
index 0000000000..1d0911d12f
--- /dev/null
+++ b/src/regress/lib/libc/orientation/orientation_test.c
@@ -0,0 +1,251 @@
+/*      $OpenBSD: orientation_test.c,v 1.3 2011/10/16 14:39:01 stsp Exp $ */
+
+/*
+ * Copyright (c) 2009 Philip Guenther
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    - Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    - 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 COPYRIGHT HOLDERS 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
+ * COPYRIGHT HOLDERS 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 whether the various stdio functions set the stream orientation
+ * ("width") as they should
+ */
+
+#include <sys/types.h>
+#include <err.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wchar.h>
+
+char filename[] = "/tmp/fwide.XXXXXXXXXX";
+
+FILE *dup_stdout = NULL;
+int failures = 0;
+
+void
+fail(int line, int r, char const *expect, char const *test)
+{
+        failures++;
+        fprintf(dup_stdout,
+                "FAIL: %d: fwide returned %d, expected %s 0 after %s\n",
+                line, r, expect, test);
+}
+
+FILE *
+setup(int line)
+{
+        FILE    *f;
+        int     r;
+
+        if ((f = fopen(filename, "r+")) == NULL)
+                err(2, "fopen");
+        if ((r = fwide(f, 0)) != 0)
+                fail(line, r, "==", "fopen");
+        return (f);
+}
+
+FILE *
+setup_std(FILE *std, int line)
+{
+        int     r;
+
+        if (freopen(filename, "r+", std) == NULL)
+                err(2, "freopen");
+        if ((r = fwide(std, 0)) != 0)
+                fail(line, r, "==", "freopen");
+        return (std);
+}
+
+#define TEST_(x, op)                                            \
+        do {                                                    \
+                f = setup(__LINE__);                            \
+                x;                                              \
+                if (!((r = fwide(f, 0)) op 0))                  \
+                        fail(__LINE__, r, #op, #x);             \
+                fclose(f);                                      \
+        } while (0)
+
+#define TEST_STD_(std, x, op)                                   \
+        do {                                                    \
+                f = setup_std(std, __LINE__);                   \
+                x;                                              \
+                if (!((r = fwide(f, 0)) op 0))                  \
+                        fail(__LINE__, r, #op, #x);             \
+        } while (0)
+
+#define TEST_UNCHANGED(x)               TEST_(x, ==)
+#define TEST_NARROW(x)                  TEST_(x, <)
+#define TEST_WIDE(x)                    TEST_(x, >)
+#define TEST_UNCHANGED_STD(std, x)      TEST_STD_(std, x, ==)
+#define TEST_NARROW_STD(std, x)         TEST_STD_(std, x, <)
+#define TEST_WIDE_STD(std, x)           TEST_STD_(std, x, >)
+
+int
+main(int argc, char *argv[])
+{
+        char    buffer[BUFSIZ];
+        wchar_t wbuffer[BUFSIZ];
+        FILE    *f;
+        off_t   off;
+        fpos_t  pos;
+        size_t  size;
+        int     fd, r;
+        char    c;
+        wchar_t wc;
+
+        if ((fd = dup(1)) == -1)
+                err(2, "dup");
+        if ((dup_stdout = fdopen(fd, "w")) == NULL)
+                err(2, "fdopen");
+        if ((fd = mkstemp(filename)) == -1)
+                err(2, "mkstemp");
+        if (write(fd, "0123456789\n\n", 12) != 12 || close(fd))
+                err(2, "write + close");
+
+        /* status */
+        TEST_UNCHANGED(fwide(f, 0));
+        TEST_NARROW(fwide(f, -1));
+        TEST_WIDE(fwide(f, 1));
+        TEST_UNCHANGED(feof(f));
+        TEST_UNCHANGED(ferror(f));
+        TEST_UNCHANGED(fileno(f));
+        TEST_UNCHANGED(clearerr(f));
+
+        /* flush and purge */
+        TEST_UNCHANGED(fflush(f));
+        TEST_UNCHANGED(fpurge(f));
+
+        /* positioning */
+        TEST_UNCHANGED(fgetpos(f, &pos));
+        TEST_UNCHANGED(fgetpos(f, &pos); fsetpos(f, &pos));
+        TEST_UNCHANGED(ftell(f));
+        TEST_UNCHANGED(ftello(f));
+        TEST_UNCHANGED(fseek(f, 1, SEEK_CUR));
+        TEST_UNCHANGED(fseek(f, 1, SEEK_SET));
+        TEST_UNCHANGED(fseek(f, 1, SEEK_END));
+        TEST_UNCHANGED(fseeko(f, 1, SEEK_CUR));
+        TEST_UNCHANGED(fseeko(f, 1, SEEK_SET));
+        TEST_UNCHANGED(fseeko(f, 1, SEEK_END));
+        TEST_UNCHANGED(rewind(f));
+
+        /* buffering */
+        TEST_UNCHANGED(setbuf(f, NULL));
+        TEST_UNCHANGED(setbuf(f, buffer));
+        TEST_UNCHANGED(setvbuf(f, buffer, _IONBF, BUFSIZ));
+        TEST_UNCHANGED(setvbuf(f, buffer, _IOLBF, BUFSIZ));
+        TEST_UNCHANGED(setvbuf(f, buffer, _IOFBF, BUFSIZ));
+        TEST_UNCHANGED(setvbuf(f, NULL, _IONBF, 0));
+        TEST_UNCHANGED(setvbuf(f, NULL, _IOLBF, 0));
+        TEST_UNCHANGED(setvbuf(f, NULL, _IOFBF, 0));
+        TEST_UNCHANGED(setbuffer(f, NULL, 0));
+        TEST_UNCHANGED(setbuffer(f, buffer, BUFSIZ));
+        TEST_UNCHANGED(setlinebuf(f));
+
+        /* locking */
+        TEST_UNCHANGED(flockfile(f);funlockfile(f));
+        TEST_UNCHANGED(ftrylockfile(f);funlockfile(f));
+
+        /* input */
+        TEST_NARROW(getc(f));
+        TEST_NARROW(getc_unlocked(f));
+        TEST_NARROW(fgetc(f));
+        TEST_NARROW(c = fgetc(f); ungetc(c, f));
+        TEST_NARROW(fgets(buffer, BUFSIZ, f));
+        TEST_NARROW(fscanf(f, "%s\n", buffer));
+        TEST_NARROW(fgetln(f, &size));
+
+        /* output */
+        TEST_NARROW(putc('c', f));
+        TEST_NARROW(putc_unlocked('c', f));
+        TEST_NARROW(fputc('c', f));
+        TEST_NARROW(fputs("foo", f));
+        TEST_NARROW(fprintf(f, "%s\n", "foo"));
+
+        /* input from stdin */
+        TEST_NARROW_STD(stdin, getchar());
+        TEST_NARROW_STD(stdin, getchar_unlocked());
+        TEST_NARROW_STD(stdin, gets(buffer));
+        TEST_NARROW_STD(stdin, scanf("%s\n", buffer));
+
+        /* output to stdout */
+        TEST_NARROW_STD(stdout, putchar('c'));
+        TEST_NARROW_STD(stdout, putchar_unlocked('c'));
+        TEST_NARROW_STD(stdout, puts("foo"));
+        TEST_NARROW_STD(stdout, printf("foo"));
+
+        /* word-size ops */
+        /*
+         * fread and fwrite are specified as being implemented in
+         * terms of fgetc() and fputc() and therefore must set the
+         * stream orientation to narrow.
+         */
+        TEST_NARROW(fread(buffer, 4, BUFSIZ / 4, f));
+        TEST_NARROW(fwrite(buffer, 4, BUFSIZ / 4, f));
+
+        /*
+         * getw() and putw() aren't specified anywhere but logically
+         * should behave the same as fread/fwrite.  Not all OSes agree:
+         * Solaris 10 has them not changing the orientation.
+         */
+        TEST_NARROW(getw(f));
+        TEST_NARROW(putw(1234, f));
+
+
+        /* WIDE CHAR TIME! */
+
+        /* input */
+        TEST_WIDE(getwc(f));
+        TEST_WIDE(fgetwc(f));
+        TEST_WIDE(wc = fgetwc(f); ungetwc(wc, f));
+        TEST_WIDE(fgetws(wbuffer, BUFSIZ, f));
+        TEST_WIDE(fwscanf(f, L"%s\n", wbuffer));
+
+        /* output */
+        TEST_WIDE(putwc(L'c', f));
+        TEST_WIDE(fputwc(L'c', f));
+        TEST_WIDE(fputws(L"foo", f));
+        TEST_WIDE(fwprintf(f, L"%s\n", L"foo"));
+
+        /* input from stdin */
+        TEST_WIDE_STD(stdin, getwchar());
+        TEST_WIDE_STD(stdin, wscanf(L"%s\n", wbuffer));
+
+        /* output to stdout */
+        TEST_WIDE_STD(stdout, putwchar(L'c'));
+        TEST_WIDE_STD(stdout, wprintf(L"foo"));
+
+
+        TEST_UNCHANGED_STD(stderr, perror("foo"));
+
+        remove(filename);
+        if (failures)
+                exit(1);
+        exit(0);
+}
+
diff --git a/src/regress/lib/libc/popen/Makefile b/src/regress/lib/libc/popen/Makefile
new file mode 100644
index 0000000000..25b8668a7a
--- /dev/null
+++ b/src/regress/lib/libc/popen/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2002/02/16 01:55:09 art Exp $
+
+PROG=popen
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/popen/popen.c b/src/regress/lib/libc/popen/popen.c
new file mode 100644
index 0000000000..916cb71b03
--- /dev/null
+++ b/src/regress/lib/libc/popen/popen.c
@@ -0,0 +1,98 @@
+/*      $NetBSD: popen.c,v 1.1 1999/09/30 09:23:23 tron Exp $   */
+
+/*-
+ * Copyright (c) 1999 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Matthias Scheler.
+ *
+ * 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.
+ */
+
+#include <sys/param.h>
+
+#include <err.h>
+#include <errno.h>
+#include <paths.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+
+#define _PATH_CAT       "/bin/cat"
+#define BUFSIZE         (640*1024)
+                        /* 640KB ought to be enough for everyone. */
+#define DATAFILE        "popen.data"
+
+int
+main(int argc, char **argv)
+{
+        char *buffer, command[MAXPATHLEN];
+        int index, in;
+        FILE *pipe;
+
+        if ((buffer = malloc(BUFSIZE*sizeof(char))) == NULL)
+            err(1, NULL);
+
+        for (index=0; index<BUFSIZE; index++)
+            buffer[index]=arc4random();
+
+        (void)snprintf(command, sizeof(command), "%s >%s",
+                       _PATH_CAT, DATAFILE);
+        if ((pipe = popen(command, "w")) == NULL)
+            err(1, "popen write");
+
+        if (fwrite(buffer, sizeof(char), BUFSIZE, pipe) != BUFSIZE)
+            err(1, "write");
+
+        if (pclose(pipe) == -1)
+            err(1, "pclose");
+
+        (void)snprintf(command, sizeof(command), "%s %s",
+                       _PATH_CAT, DATAFILE);
+        if ((pipe = popen(command, "r")) == NULL)
+            err(1, "popen read");
+
+        index = 0;
+        while ((in = fgetc(pipe)) != EOF)
+            if (index == BUFSIZE) {
+                errno = EFBIG;
+                err(1, "read");
+            }
+            else
+                if ((char)in != buffer[index++]) {
+                    errno = EINVAL;
+                    err(1, "read");
+                }
+
+        if (index < BUFSIZE) {
+            errno = EIO;
+            err(1, "read");
+        }
+
+        if (pclose(pipe) == -1)
+            err(1, "pclose");
+
+        (void)unlink(DATAFILE);
+        return 0;
+}
diff --git a/src/regress/lib/libc/printf/Makefile b/src/regress/lib/libc/printf/Makefile
new file mode 100644
index 0000000000..c2e2732d6e
--- /dev/null
+++ b/src/regress/lib/libc/printf/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2008/09/07 20:36:10 martynas Exp $
+
+PROG=   fp
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/printf/fp.c b/src/regress/lib/libc/printf/fp.c
new file mode 100644
index 0000000000..6ed52fdb49
--- /dev/null
+++ b/src/regress/lib/libc/printf/fp.c
@@ -0,0 +1,217 @@
+/*      $OpenBSD: fp.c,v 1.1 2008/09/07 20:36:10 martynas Exp $ */
+/*-
+ * Copyright (c) 2002, 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 printf() floating point formats.
+ */
+
+#include <assert.h>
+#include <err.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define testfmt(result, fmt, ...)       \
+        _testfmt((result), __LINE__, #__VA_ARGS__, fmt, __VA_ARGS__)
+void _testfmt(const char *, int, const char *, const char *, ...);
+void smash_stack(void);
+
+int
+main(int argc, char *argv[])
+{
+        /*
+         * Basic tests of decimal output functionality.
+         */
+        testfmt(" 1.000000E+00", "%13E", 1.0);
+        testfmt("     1.000000", "%13f", 1.0);
+        testfmt("            1", "%13G", 1.0);
+        testfmt(" 1.000000E+00", "%13LE", 1.0L);
+        testfmt("     1.000000", "%13Lf", 1.0L);
+        testfmt("            1", "%13LG", 1.0L);
+
+        testfmt("2.718282", "%.*f", -2, 2.7182818);
+
+        testfmt("1.234568e+06", "%e", 1234567.8);
+        testfmt("1234567.800000", "%f", 1234567.8);
+        testfmt("1.23457E+06", "%G", 1234567.8);
+        testfmt("1.234568e+06", "%Le", 1234567.8L);
+        testfmt("1234567.800000", "%Lf", 1234567.8L);
+        testfmt("1.23457E+06", "%LG", 1234567.8L);
+
+#if (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__)
+        testfmt("123456789.864210", "%Lf", 123456789.8642097531L);
+        testfmt("-1.23457E+08", "%LG", -123456789.8642097531L);
+        testfmt("123456789.8642097531", "%.10Lf", 123456789.8642097531L);
+        testfmt(" 3.141592653589793238e-4000", "%L27.18Le",
+            3.14159265358979323846e-4000L);
+#endif /* (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__) */
+
+        /*
+         * Infinities and NaNs
+         */
+#ifdef NAN
+        testfmt("nan", "%e", NAN);
+        testfmt("NAN", "%F", NAN);
+        testfmt("nan", "%g", NAN);
+        testfmt("NAN", "%LE", (long double)NAN);
+        testfmt("  nan", "%05e", NAN);
+#endif /* NAN */
+
+        testfmt("INF", "%E", HUGE_VAL);
+        testfmt("-inf", "%f", -HUGE_VAL);
+        testfmt("+inf", "%+g", HUGE_VAL);
+        testfmt(" inf", "%4.2Le", HUGE_VALL);
+        testfmt("-inf", "%Lf", -HUGE_VALL);
+        testfmt("  inf", "%05e", HUGE_VAL);
+        testfmt(" -inf", "%05e", -HUGE_VAL);
+
+        /*
+         * Padding
+         */
+        testfmt("0.000000e+00", "%e", 0.0);
+        testfmt("0.000000", "%F", (double)0.0);
+        testfmt("0", "%G", 0.0);
+        testfmt("  0", "%3.0Lg", 0.0L);
+        testfmt("    0", "%5.0f", 0.001);
+
+        /*
+         * Precision specifiers
+         */
+        testfmt("1.0123e+00", "%.4e", 1.0123456789);
+        testfmt("1.0123", "%.4f", 1.0123456789);
+        testfmt("1.012", "%.4g", 1.0123456789);
+        testfmt("1.2346e-02", "%.4e", 0.0123456789);
+        testfmt("0.0123", "%.4f", 0.0123456789);
+        testfmt("0.01235", "%.4g", 0.0123456789);
+
+        /*
+         * Signed conversions
+         */
+        testfmt("+2.500000e-01", "%+e", 0.25);
+        testfmt("+0.000000", "%+F", 0.0);
+        testfmt("-1", "%+g", -1.0);
+
+        testfmt("-1.000000e+00", "% e", -1.0);
+        testfmt("+1.000000", "% +f", 1.0);
+        testfmt(" 1", "% g", 1.0);
+        testfmt(" 0", "% g", 0.0);
+
+        /*
+         * ``Alternate form''
+         */
+        testfmt("1.250e+00", "%#.3e", 1.25);
+        testfmt("123.000000", "%#f", 123.0);
+        testfmt(" 12345.", "%#7.5g", 12345.0);
+        testfmt(" 1.00000", "%#8g", 1.0);
+        testfmt("0.0", "%#.2g", 0.0);
+
+        /*
+         * Padding and decimal point placement
+         */
+        testfmt("03.2E+00", "%08.1E", 3.25);
+        testfmt("003.25", "%06.2F", 3.25);
+        testfmt("0003.25", "%07.4G", 3.25);
+
+        testfmt("3.14159e-05", "%g", 3.14159e-5);
+        testfmt("0.000314159", "%g", 3.14159e-4);
+        testfmt("3.14159e+06", "%g", 3.14159e6);
+        testfmt("314159", "%g", 3.14159e5);
+        testfmt("314159.", "%#g", 3.14159e5);
+
+        testfmt(" 9.000000e+03", "%13e", 9000.0);
+        testfmt(" 9000.000000", "%12f", 9000.0);
+        testfmt(" 9000", "%5g", 9000.0);
+        testfmt(" 900000.", "%#8g", 900000.0);
+        testfmt(" 9e+06", "%6g", 9000000.0);
+        testfmt(" 9.000000e-04", "%13e", 0.0009);
+        testfmt(" 0.000900", "%9f", 0.0009);
+        testfmt(" 0.0009", "%7g", 0.0009);
+        testfmt(" 9e-05", "%6g", 0.00009);
+        testfmt(" 9.00000e-05", "%#12g", 0.00009);
+        testfmt(" 9.e-05", "%#7.1g", 0.00009);
+
+        testfmt(" 0.0", "%4.1f", 0.0);
+        testfmt("90.0", "%4.1f", 90.0);
+        testfmt(" 100", "%4.0f", 100.0);
+        testfmt("9.0e+01", "%4.1e", 90.0);
+        testfmt("1e+02", "%4.0e", 100.0);
+
+        /*
+         * Hexadecimal floating point (%a, %A) tests.  Some of these
+         * are only valid if the implementation converts to hex digits
+         * on nibble boundaries.
+         */
+        testfmt("0x0p+0", "%a", 0x0.0p0);
+        testfmt("0X0.P+0", "%#LA", 0x0.0p0L);
+#ifdef NAN
+        testfmt("inf", "%La", (long double)INFINITY);
+        testfmt("+INF", "%+A", INFINITY);
+        testfmt("nan", "%La", (long double)NAN);
+        testfmt("NAN", "%A", NAN);
+#endif /* NAN */
+
+        testfmt(" 0x1.23p+0", "%10a", 0x1.23p0);
+        testfmt(" 0x1.23p-500", "%12a", 0x1.23p-500);
+        testfmt(" 0x1.2p+40", "%10.1a", 0x1.23p40);
+        testfmt(" 0X1.230000000000000000000000P-4", "%32.24A", 0x1.23p-4);
+        testfmt("0x1p-1074", "%a", 0x1p-1074);
+        testfmt("0x1.2345p-1024", "%a", 0x1.2345p-1024);
+
+        return (0);
+}
+
+void
+smash_stack(void)
+{
+        static uint32_t junk = 0xdeadbeef;
+        uint32_t buf[512];
+        int i;
+
+        for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++)
+                buf[i] = junk;
+}
+
+void
+_testfmt(const char *result, int line, const char *argstr, const char *fmt,...)
+{
+        char s[100];
+        va_list ap;
+
+        va_start(ap, fmt);
+        smash_stack();
+        vsnprintf(s, sizeof(s), fmt, ap);
+        if (strcmp(result, s) != 0) {
+                fprintf(stderr,
+                    "%d: printf(\"%s\", %s) ==> [%s], expected [%s]\n",
+                    line, fmt, argstr, s, result);
+                abort();
+        }
+}
diff --git a/src/regress/lib/libc/regex/Makefile b/src/regress/lib/libc/regex/Makefile
index 93b7bb9052..271debb5d3 100644
--- a/src/regress/lib/libc/regex/Makefile
+++ b/src/regress/lib/libc/regex/Makefile
@@ -1,16 +1,21 @@
+#       $OpenBSD: Makefile,v 1.6 2004/08/13 14:54:12 millert Exp $
 #       $NetBSD: Makefile,v 1.2 1995/02/16 19:38:45 cgd Exp $
 
 PROG=   re
-SRCS=   main.c split.c debug.c
-NOMAN=
+SRCS=   main.c split.c debug.c regcomp.c regerror.c regexec.c regfree.c
+.PATH: ${.CURDIR}/../../../../lib/libc/regex
 
-CFLAGS+= -I${.CURDIR}/../../../../lib/libc/regex
+CFLAGS+= -I${.CURDIR}/../../../../lib/libc/regex -DREDEBUG -DPOSIX_MISTAKE
 
 TESTS=  ${.CURDIR}/tests
 
-regress:
+REGRESS_TARGETS=do-reg do-reg-long do-reg-backref
+
+do-reg: ${PROG}
         ./re < ${TESTS}
+do-reg-long: ${PROG}
         ./re -el < ${TESTS}
+do-reg-backref: ${PROG}
         ./re -er < ${TESTS}
 
-.include <bsd.prog.mk>
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/regex/debug.c b/src/regress/lib/libc/regex/debug.c
index 861f550611..11129e7249 100644
--- a/src/regress/lib/libc/regex/debug.c
+++ b/src/regress/lib/libc/regex/debug.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: debug.c,v 1.4 2003/07/31 21:48:03 deraadt Exp $       */
 /*      $NetBSD: debug.c,v 1.2 1995/04/20 22:39:42 cgd Exp $    */
 
 #include <stdio.h>
@@ -218,7 +219,7 @@ FILE *d;
                         fprintf(d, ">");
                         break;
                 default:
-                        fprintf(d, "!%d(%d)!", OP(*s), opnd);
+                        fprintf(d, "!%ld(%ld)!", (long)OP(*s), (long)opnd);
                         break;
                 }
                 if (!done)
@@ -237,8 +238,8 @@ int ch;
         static char buf[10];
 
         if (isprint(ch) || ch == ' ')
-                sprintf(buf, "%c", ch);
+                snprintf(buf, sizeof buf, "%c", ch);
         else
-                sprintf(buf, "\\%o", ch);
+                snprintf(buf, sizeof buf, "\\%o", ch);
         return(buf);
 }
diff --git a/src/regress/lib/libc/regex/debug.ih b/src/regress/lib/libc/regex/debug.ih
index fb9bac0c75..9eb313af23 100644
--- a/src/regress/lib/libc/regex/debug.ih
+++ b/src/regress/lib/libc/regex/debug.ih
@@ -1,3 +1,4 @@
+/*      $OpenBSD: debug.ih,v 1.3 2002/02/16 21:27:32 millert Exp $      */
 /*      $NetBSD: debug.ih,v 1.2 1995/04/20 22:39:47 cgd Exp $   */
 
 /* ========= begin header generated by ./mkh ========= */
@@ -6,9 +7,9 @@ extern "C" {
 #endif
 
 /* === debug.c === */
-void regprint __P((regex_t *r, FILE *d));
-static void s_print __P((register struct re_guts *g, FILE *d));
-static char *regchar __P((int ch));
+void regprint(regex_t *r, FILE *d);
+static void s_print(register struct re_guts *g, FILE *d);
+static char *regchar(int ch);
 
 #ifdef __cplusplus
 }
diff --git a/src/regress/lib/libc/regex/main.c b/src/regress/lib/libc/regex/main.c
index 8d88a8b9b8..e0ed86f5e8 100644
--- a/src/regress/lib/libc/regex/main.c
+++ b/src/regress/lib/libc/regex/main.c
@@ -1,10 +1,13 @@
+/*      $OpenBSD: main.c,v 1.7 2007/09/12 19:32:35 otto Exp $   */
 /*      $NetBSD: main.c,v 1.2 1995/04/20 22:39:51 cgd Exp $     */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <regex.h>
 #include <assert.h>
+#include <unistd.h>
 
 #include "main.ih"
 
@@ -19,15 +22,15 @@ regoff_t startoff = 0;
 regoff_t endoff = 0;
 
 
-extern int split();
-extern void regprint();
+extern int split(char *, char *[], int, char *);
+extern void regprint(regex_t *, FILE *);
 
 /*
  - main - do the simple case, hand off to regress() for regression
  */
-main(argc, argv)
-int argc;
-char *argv[];
+int
+main(int argc, char *argv[])
+
 {
         regex_t re;
 #       define  NS      10
@@ -43,7 +46,7 @@ char *argv[];
 
         progname = argv[0];
 
-        while ((c = getopt(argc, argv, "c:e:S:E:x")) != EOF)
+        while ((c = getopt(argc, argv, "c:e:S:E:x")) != -1)
                 switch (c) {
                 case 'c':       /* compile options */
                         copts = options('c', optarg);
@@ -79,7 +82,7 @@ char *argv[];
         err = regcomp(&re, argv[optind++], copts);
         if (err) {
                 len = regerror(err, &re, erbuf, sizeof(erbuf));
-                fprintf(stderr, "error %s, %d/%d `%s'\n",
+                fprintf(stderr, "error %s, %zu/%zu `%s'\n",
                         eprint(err), len, sizeof(erbuf), erbuf);
                 exit(status);
         }
@@ -97,15 +100,15 @@ char *argv[];
         err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
         if (err) {
                 len = regerror(err, &re, erbuf, sizeof(erbuf));
-                fprintf(stderr, "error %s, %d/%d `%s'\n",
+                fprintf(stderr, "error %s, %zu/%zu `%s'\n",
                         eprint(err), len, sizeof(erbuf), erbuf);
                 exit(status);
         }
         if (!(copts&REG_NOSUB)) {
-                len = (int)(subs[0].rm_eo - subs[0].rm_so);
+                len = (size_t)(subs[0].rm_eo - subs[0].rm_so);
                 if (subs[0].rm_so != -1) {
                         if (len != 0)
-                                printf("match `%.*s'\n", len,
+                                printf("match `%.*s'\n", (int)len,
                                         argv[optind] + subs[0].rm_so);
                         else
                                 printf("match `'@%.1s\n",
@@ -144,7 +147,7 @@ FILE *in;
                 line++;
                 if (inbuf[0] == '#' || inbuf[0] == '\n')
                         continue;                       /* NOTE CONTINUE */
-                inbuf[strlen(inbuf)-1] = '\0';  /* get rid of stupid \n */
+                inbuf[strcspn(inbuf, "\n")] = '\0';     /* get rid of stupid \n */
                 if (debug)
                         fprintf(stdout, "%d:\n", line);
                 nf = split(inbuf, f, MAXF, "\t\t");
@@ -225,14 +228,14 @@ int opts;			/* may not match f1 */
         char f0copy[1000];
         char f2copy[1000];
 
-        strcpy(f0copy, f0);
+        strlcpy(f0copy, f0, sizeof f0copy);
         re.re_endp = (opts&REG_PEND) ? f0copy + strlen(f0copy) : NULL;
         fixstr(f0copy);
         err = regcomp(&re, f0copy, opts);
         if (err != 0 && (!opt('C', f1) || err != efind(f2))) {
                 /* unexpected error or wrong error */
                 len = regerror(err, &re, erbuf, sizeof(erbuf));
-                fprintf(stderr, "%d: %s error %s, %d/%d `%s'\n",
+                fprintf(stderr, "%d: %s error %s, %d/%zu `%s'\n",
                                         line, type, eprint(err), len,
                                         sizeof(erbuf), erbuf);
                 status = 1;
@@ -249,7 +252,7 @@ int opts;			/* may not match f1 */
                 return;
         }
 
-        strcpy(f2copy, f2);
+        strlcpy(f2copy, f2, sizeof f2copy);
         fixstr(f2copy);
 
         if (options('e', f1)&REG_STARTEND) {
@@ -263,7 +266,7 @@ int opts;			/* may not match f1 */
         if (err != 0 && (f3 != NULL || err != REG_NOMATCH)) {
                 /* unexpected error or wrong error */
                 len = regerror(err, &re, erbuf, sizeof(erbuf));
-                fprintf(stderr, "%d: %s exec error %s, %d/%d `%s'\n",
+                fprintf(stderr, "%d: %s exec error %s, %d/%zu `%s'\n",
                                         line, type, eprint(err), len,
                                         sizeof(erbuf), erbuf);
                 status = 1;
@@ -427,8 +430,9 @@ char *should;
                                 (sub.rm_so != -1 && sub.rm_eo == -1) ||
                                 (sub.rm_so != -1 && sub.rm_so < 0) ||
                                 (sub.rm_eo != -1 && sub.rm_eo < 0) ) {
-                sprintf(grump, "start %ld end %ld", (long)sub.rm_so,
-                                                        (long)sub.rm_eo);
+                snprintf(grump, sizeof grump,
+                    "start %ld end %ld", (long)sub.rm_so,
+                    (long)sub.rm_eo);
                 return(grump);
         }
 
@@ -440,8 +444,9 @@ char *should;
 
         /* check for in range */
         if (sub.rm_eo > strlen(str)) {
-                sprintf(grump, "start %ld end %ld, past end of string",
-                                        (long)sub.rm_so, (long)sub.rm_eo);
+                snprintf(grump, sizeof grump,
+                        "start %ld end %ld, past end of string",
+                        (long)sub.rm_so, (long)sub.rm_eo);
                 return(grump);
         }
 
@@ -451,13 +456,13 @@ char *should;
 
         /* check for not supposed to match */
         if (should == NULL) {
-                sprintf(grump, "matched `%.*s'", len, p);
+                snprintf(grump, sizeof grump, "matched `%.*s'", len, p);
                 return(grump);
         }
 
         /* check for wrong match */
         if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
-                sprintf(grump, "matched `%.*s' instead", len, p);
+                snprintf(grump, sizeof grump, "matched `%.*s' instead", len, p);
                 return(grump);
         }
         if (shlen > 0)
@@ -470,7 +475,7 @@ char *should;
         if (shlen == 0)
                 shlen = 1;      /* force check for end-of-string */
         if (strncmp(p, at, shlen) != 0) {
-                sprintf(grump, "matched null at `%.20s'", p);
+                snprintf(grump, sizeof grump, "matched null at `%.20s'", p);
                 return(grump);
         }
         return(NULL);
@@ -501,10 +506,9 @@ efind(name)
 char *name;
 {
         static char efbuf[100];
-        size_t n;
         regex_t re;
 
-        sprintf(efbuf, "REG_%s", name);
+        snprintf(efbuf, sizeof efbuf, "REG_%s", name);
         assert(strlen(efbuf) < sizeof(efbuf));
         re.re_endp = efbuf;
         (void) regerror(REG_ATOI, &re, efbuf, sizeof(efbuf));
diff --git a/src/regress/lib/libc/regex/main.ih b/src/regress/lib/libc/regex/main.ih
index 135e3e792d..0860e26333 100644
--- a/src/regress/lib/libc/regex/main.ih
+++ b/src/regress/lib/libc/regex/main.ih
@@ -1,3 +1,4 @@
+/*      $OpenBSD: main.ih,v 1.3 2002/02/16 21:27:32 millert Exp $       */
 /*      $NetBSD: main.ih,v 1.2 1995/04/20 22:39:55 cgd Exp $    */
 
 /* ========= begin header generated by ./mkh ========= */
@@ -6,14 +7,14 @@ extern "C" {
 #endif
 
 /* === main.c === */
-void regress __P((FILE *in));
-void try __P((char *f0, char *f1, char *f2, char *f3, char *f4, int opts));
-int options __P((int type, char *s));
-int opt __P((int c, char *s));
-void fixstr __P((register char *p));
-char *check __P((char *str, regmatch_t sub, char *should));
-static char *eprint __P((int err));
-static int efind __P((char *name));
+void regress(FILE *in);
+void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
+int options(int type, char *s);
+int opt(int c, char *s);
+void fixstr(register char *p);
+char *check(char *str, regmatch_t sub, char *should);
+static char *eprint(int err);
+static int efind(char *name);
 
 #ifdef __cplusplus
 }
diff --git a/src/regress/lib/libc/regex/split.c b/src/regress/lib/libc/regex/split.c
index dd1ca14480..fcd81a3503 100644
--- a/src/regress/lib/libc/regex/split.c
+++ b/src/regress/lib/libc/regex/split.c
@@ -1,18 +1,17 @@
+/*      $OpenBSD: split.c,v 1.5 2007/09/09 23:25:12 chl Exp $   */
 /*      $NetBSD: split.c,v 1.2 1995/04/20 22:39:57 cgd Exp $    */
 
 #include <stdio.h>
 #include <string.h>
 
+int split(char *string, char *fields[], int nfields, char *sep);
+
 /*
  - split - divide a string into fields, like awk split()
  = int split(char *string, char *fields[], int nfields, char *sep);
  */
 int                             /* number of fields, including overflow */
-split(string, fields, nfields, sep)
-char *string;
-char *fields[];                 /* list is not NULL-terminated */
-int nfields;                    /* number of entries available in fields[] */
-char *sep;                      /* "" white, "c" single char, "ab" [ab]+ */
+split(char *string, char *fields[], int nfields, char *sep)
 {
         register char *p = string;
         register char c;                        /* latest character */
@@ -161,18 +160,18 @@ char *argv[];
 
         if (argc > 4)
                 for (n = atoi(argv[3]); n > 0; n--) {
-                        (void) strcpy(buf, argv[1]);
+                        (void) strlcpy(buf, argv[1], sizeof buf);
                 }
         else if (argc > 3)
                 for (n = atoi(argv[3]); n > 0; n--) {
-                        (void) strcpy(buf, argv[1]);
+                        (void) strlcpy(buf, argv[1], sizeof buf);
                         (void) split(buf, fields, MNF, argv[2]);
                 }
         else if (argc > 2)
                 dosplit(argv[1], argv[2]);
         else if (argc > 1)
                 while (fgets(buf, sizeof(buf), stdin) != NULL) {
-                        buf[strlen(buf)-1] = '\0';      /* stomp newline */
+                        buf[strcspn(buf, "\n")] = '\0'; /* stomp newline */
                         dosplit(buf, argv[1]);
                 }
         else
@@ -287,7 +286,7 @@ regress()
         register char *f;
 
         for (n = 0; tests[n].str != NULL; n++) {
-                (void) strcpy(buf, tests[n].str);
+                (void) strlcpy(buf, tests[n].str, sizeof buf);
                 fields[RNF] = NULL;
                 nf = split(buf, fields, RNF, tests[n].seps);
                 printit = 0;
diff --git a/src/regress/lib/libc/regex/tests b/src/regress/lib/libc/regex/tests
index 8e89f161b1..c827c868b7 100644
--- a/src/regress/lib/libc/regex/tests
+++ b/src/regress/lib/libc/regex/tests
@@ -1,3 +1,4 @@
+#       $OpenBSD: tests,v 1.5 2004/11/29 16:50:31 otto Exp $
 #       $NetBSD: tests,v 1.5 1995/04/20 22:40:00 cgd Exp $
 
 # regular expression test set
@@ -168,6 +169,30 @@ a\(\(b\)*\2\)*d		b	abbbd	abbbd
 \(a\)\1bc*d     b       aabcccd aabcccd
 \(a\)\1bc*[ce]d b       aabcccd aabcccd
 ^\(a\)\1b\(c\)*cd$      b       aabcccd aabcccd
+\(b*\)\(a*\1\)* b       ab      a
+\([^_]*\)\(_*\1\)*      b       foo_foo_bar_bar_bar_baz foo_foo foo,_foo
+\([^_]*\)\(_*\1\)*      b       bar_bar_bar_baz bar_bar_bar     bar,_bar
+\([^_]*\)\(_*\1\)*      b       foo_bar_baz     foo     foo
+\(.*\)\1        b       ""      ""
+\(.*\)\1        b       a       ""
+\(.*\)\1        b       aa      aa
+\(.*\)\1        b       aaa     aa
+\(.*\)\1        b       aaaa    aaaa
+\([^_]*\)\1     b       ""      ""
+\([^_]*\)\1     b       a       ""
+\([^_]*\)\1     b       aa      aa
+\([^_]*\)\1     b       aaa     aa
+\([^_]*\)\1     b       aaaa    aaaa
+foo\(.*\)bar\1  b       foolbarl        foolbarl        l
+foo\(.*\)bar\1  b       foobar  foobar  ""
+\(\(.\)b\)*\1   b       aba
+\(\(.\)b\)*\1   b       abba
+\(\(.\)b\)*\1   b       abbba
+\(\(.\)b\)*\1   b       abbbba  bbbb    bb,b
+\(\(.\)b\)*\1   b       abbbbba abbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbba        abbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbbbbbbbbbba        abbbbbbbbbbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbbbbbbbbbbba       abbbbbbbbbbbbbbb        bb,b
 
 # ordinary repetitions
 ab*c            &       abc     abc
@@ -475,3 +500,4 @@ CC[13]1|a{21}[23][EO][123][Es][12]a{15}aa[34][EW]aaaaaaa[X]a	-	CC11	CC11
 Char \([a-z0-9_]*\)\[.* b       Char xyz[k      Char xyz[k      xyz
 a?b     -       ab      ab
 -\{0,1\}[0-9]*$ b       -5      -5
+
diff --git a/src/regress/lib/libc/setjmp-signal/Makefile b/src/regress/lib/libc/setjmp-signal/Makefile
new file mode 100644
index 0000000000..a9649a8abe
--- /dev/null
+++ b/src/regress/lib/libc/setjmp-signal/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2002/07/31 05:18:24 art Exp $
+
+PROG=   setjmp-signal
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/setjmp-signal/setjmp-signal.c b/src/regress/lib/libc/setjmp-signal/setjmp-signal.c
new file mode 100644
index 0000000000..310e4052ef
--- /dev/null
+++ b/src/regress/lib/libc/setjmp-signal/setjmp-signal.c
@@ -0,0 +1,26 @@
+/*      $OpenBSD: setjmp-signal.c,v 1.3 2003/01/03 20:46:05 miod Exp $  */
+/*
+ *      Written by Artur Grabowski <art@openbsd.org> 2002 Public Domain.
+ */
+
+#include <setjmp.h>
+#include <signal.h>
+
+jmp_buf jb;
+
+void
+segv_handler(int signum)
+{
+        longjmp(jb, 1);
+}
+
+int
+main()
+{
+        signal(SIGSEGV, segv_handler);
+        if (setjmp(jb) == 0) {
+                *((int *)0L) = 0;
+                return (1);
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/setjmp/Makefile b/src/regress/lib/libc/setjmp/Makefile
index 25bf99d4cb..fc68e8d44c 100644
--- a/src/regress/lib/libc/setjmp/Makefile
+++ b/src/regress/lib/libc/setjmp/Makefile
@@ -1,16 +1,9 @@
+#       $OpenBSD: Makefile,v 1.3 2002/01/01 23:00:51 art Exp $
 #       $NetBSD: Makefile,v 1.2 1995/04/20 22:40:13 cgd Exp $
 
 PROG=   setjmptest
 SRCS=   jmptest.c
-NOMAN=  noman, no way, man
 
 CFLAGS+= -DTEST_SETJMP
 
-.PATH:  ${.CURDIR}/../setjmp
-
-install:
-
-regress: ${PROG}
-        ./${PROG}
-
-.include <bsd.prog.mk>
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/setjmp/jmptest.c b/src/regress/lib/libc/setjmp/jmptest.c
index f2cecc9178..9512c9ee34 100644
--- a/src/regress/lib/libc/setjmp/jmptest.c
+++ b/src/regress/lib/libc/setjmp/jmptest.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: jmptest.c,v 1.7 2003/09/02 23:52:16 david Exp $       */
 /*      $NetBSD: jmptest.c,v 1.2 1995/01/01 20:55:35 jtc Exp $  */
 
 /*
@@ -32,10 +33,12 @@
  */
 
 #include <sys/types.h>
+#include <err.h>
 #include <setjmp.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
 #if (TEST_SETJMP + TEST_U_SETJMP + TEST_SIGSETJMP) != 1
@@ -62,21 +65,20 @@
 
 int expectsignal;
 
-void
-aborthandler(signo)
-        int signo;
+static void
+aborthandler(int signo)
 {
 
         if (expectsignal)
-                exit(0);
-        else
-                errx(1, "kill(SIGABRT) succeeded");
+                _exit(0);
+        else {
+                warnx("kill(SIGABRT) succeeded");
+                _exit(1);
+        }
 }
 
 int
-main(argc, argv)
-        int argc;
-        char *argv[];
+main(int argc, char *argv[])
 {
         struct sigaction sa;
         BUF jb;
@@ -101,7 +103,7 @@ main(argc, argv)
 #endif
 
         sa.sa_handler = aborthandler;
-        sa.sa_mask = 0;
+        sigemptyset(&sa.sa_mask);
         sa.sa_flags = 0;
         if (sigaction(SIGABRT, &sa, NULL) == -1)
                 err(1, "sigaction failed");
diff --git a/src/regress/lib/libc/sigreturn/Makefile b/src/regress/lib/libc/sigreturn/Makefile
new file mode 100644
index 0000000000..9891ba9e05
--- /dev/null
+++ b/src/regress/lib/libc/sigreturn/Makefile
@@ -0,0 +1,18 @@
+# $OpenBSD: Makefile,v 1.5 2002/09/02 20:01:43 avsm Exp $
+
+PROG=   sigret
+
+DEBUG+= -ggdb
+
+REGRESS_TARGETS+= sigret-normal sigret-indirect sigret-altstack
+
+sigret-normal: ${PROG}
+        ./${PROG}
+
+sigret-indirect: ${PROG}
+        ./${PROG} -i
+
+sigret-altstack: ${PROG}
+        ./${PROG} -a
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/sigreturn/sigret.c b/src/regress/lib/libc/sigreturn/sigret.c
new file mode 100644
index 0000000000..72945fa503
--- /dev/null
+++ b/src/regress/lib/libc/sigreturn/sigret.c
@@ -0,0 +1,181 @@
+/*
+ * $OpenBSD: sigret.c,v 1.5 2003/07/31 21:48:04 deraadt Exp $
+ *
+ * Public Domain
+ *
+ * Playing games with sigreturn.   Check if calling sigreturn from a
+ * signal handler screws anything up.
+ *
+ * Run with:
+ *      -a:     use an alternate signal stack
+ *
+ *      -b:     call sigreturn from outside of a signal handler
+ *              An error is OK
+ *
+ *      -c:     clobber the sigcontext before calling sigreturn
+ *              the program should die
+ *
+ *      -f:     don't use sigreturn -- fall through the signal handler
+ *              -c, and -i options ignored when used
+ *
+ *      -i:     call sigreturn from a function called by the signal handler
+ *
+ */
+
+#include <sys/time.h>
+
+#include <err.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*
+ * sigalarm occurs 50 times/second.  Stop running after 10 seconds
+ * (100 interrupts).
+ */
+#define MAX_INTERRUPTS  500
+
+int failed;
+int altstack;
+int badcall;
+int clobbercall;
+int fallthru;
+int indirect;
+
+volatile int count;
+struct sigcontext gscp;
+int gscp_loaded;
+
+static void
+usage(const char * err, ...)
+{
+        extern const char * __progname;
+
+        if (err) {
+                va_list ap;
+                va_start(ap, err);
+                vwarnx(err, ap);
+                va_end(ap);
+        }
+        fprintf(stderr, "usage: %s [-abcfi]\n", __progname);
+        exit(1);
+}
+
+static void
+indirect_return(struct sigcontext * scp)
+{
+        sigreturn(scp);
+}
+
+static void
+sig_handler(int sig, siginfo_t *blah, void *x)
+{
+        struct sigcontext * scp = x;
+
+        count++;
+
+        if (!fallthru) {
+                if (clobbercall)
+                        memset(scp, 0, sizeof *scp);
+                if (indirect)
+                        indirect_return(scp);
+                else if (badcall) {
+                        gscp = *scp;
+                        gscp_loaded = 1;
+                } else
+                        sigreturn(scp);
+        }
+}
+
+static void
+test2(char *fmt)
+{
+        char *ofmt = fmt;
+
+        if (gscp_loaded) {
+                gscp_loaded = 0;
+                sigreturn(&gscp);
+        }
+
+        for (; *fmt; fmt++)
+          switch (*fmt) {
+          case 'i':
+          case 'c':
+          case 'l':
+          case 'p':
+            break;
+          default:
+            failed = 1;
+            fprintf(stderr,
+                    "unexpected character 0x%02x `%c' in %s: count %d\n",
+                    *fmt, *fmt, ofmt, count);
+          }
+}
+
+int
+main(int argc, char * argv[])
+{
+        extern char *optarg;
+        extern int optind;
+
+        int opt;
+
+        struct sigaction act;
+        struct sigaltstack ss;
+
+        while ((opt = getopt(argc, argv, "abcfi")) != -1) {
+                switch (opt) {
+                case 'a':
+                        /* use sigaltstack */
+                        altstack = 1;
+                        break;
+                case 'b':
+                        /* call outside of sig_handler */
+                        badcall = 1;
+                        break;
+                case 'c':
+                        /* force error by munging sigcontext */
+                        clobbercall = 1;
+                        break;
+                case 'f':
+                        /* don't use sigreturn */
+                        fallthru = 1;
+                        break;
+                case 'i':
+                        /* call sigreturn indirectly */
+                        indirect = 1;
+                        break;
+                }
+        }
+
+        /* make sure there is no other cruft left on the command line */
+        if (optind != argc)
+                usage("unknown argument -- %s", argv[ optind ]);
+
+        if (altstack) {
+                if ((ss.ss_sp = malloc(SIGSTKSZ)) == NULL)
+                        errx(1, "ss_sp malloc");
+
+                ss.ss_size = SIGSTKSZ;
+                ss.ss_flags = 0;
+                if (sigaltstack(&ss,0) == -1)
+                        err(1, "sigaltstack");
+        }
+
+        sigfillset(&act.sa_mask);
+        act.sa_sigaction = sig_handler;
+        act.sa_flags = SA_RESTART;
+        if (altstack)
+                act.sa_flags |= SA_ONSTACK;
+        sigaction(SIGALRM, &act, NULL);
+
+        ualarm(10000, 10000);
+
+        while (count < MAX_INTERRUPTS)
+                test2("iclp");
+
+        return failed;
+}
diff --git a/src/regress/lib/libc/sigsetjmp/Makefile b/src/regress/lib/libc/sigsetjmp/Makefile
index 41682fcb66..f88bea3b47 100644
--- a/src/regress/lib/libc/sigsetjmp/Makefile
+++ b/src/regress/lib/libc/sigsetjmp/Makefile
@@ -1,17 +1,19 @@
-#       $NetBSD: Makefile,v 1.2 1995/04/20 22:40:40 cgd Exp $
+#       $OpenBSD: Makefile,v 1.5 2002/09/02 20:01:43 avsm Exp $
 
 PROG=   sigsetjmptest
 SRCS=   jmptest.c
-NOMAN=  noman, no way, man
 
 CFLAGS+= -DTEST_SIGSETJMP
 
 .PATH:  ${.CURDIR}/../setjmp
 
-install:
+REGRESS_TARGETS=sigsetjmp-save sigsetjmp-nosave
 
-regress: ${PROG}
+sigsetjmp-save: ${PROG}
         ./${PROG} save
+sigsetjmp-nosave: ${PROG}
         ./${PROG} nosave
 
-.include <bsd.prog.mk>
+.PHONY: ${REGRESS_TARGETS}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/sleep/Makefile b/src/regress/lib/libc/sleep/Makefile
new file mode 100644
index 0000000000..3700b1662a
--- /dev/null
+++ b/src/regress/lib/libc/sleep/Makefile
@@ -0,0 +1,13 @@
+#       $OpenBSD: Makefile,v 1.1 2009/12/14 05:08:19 guenther Exp $
+
+NOMAN=
+PROG=sleep_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+
+run-regress-${PROG}: ${PROG}
+        [ x$$(./${PROG} 1) = x0 ] || exit 1
+        file=$$(mktemp -t sleep.XXXXXXXXXX); ./${PROG} 4 >$$file & pid=$$!; \
+                sleep 1; kill $$pid; sleep 1; v=$$(cat $$file); rm -f $$file; \
+                { [ $$v -gt 0 ] && [ $$v -lt 4 ] ; } || exit 2
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/sleep/sleep_test.c b/src/regress/lib/libc/sleep/sleep_test.c
new file mode 100644
index 0000000000..c9ab0d095f
--- /dev/null
+++ b/src/regress/lib/libc/sleep/sleep_test.c
@@ -0,0 +1,84 @@
+/*      $OpenBSD: sleep_test.c,v 1.1 2009/12/14 05:08:19 guenther Exp $ */
+
+/*
+ * Copyright (c) 2009 Philip Guenther
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    - Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    - 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 COPYRIGHT HOLDERS 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
+ * COPYRIGHT HOLDERS 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 whether sleep returns the correct value
+ */
+
+#include <sys/types.h>
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+static void
+handler(int sig)
+{
+        return;
+}
+
+static void *
+garbage(void)
+{
+        char buf[20];
+        strlcpy(buf, "012354678901235467890123546789", sizeof buf);
+        return buf;
+}
+
+int
+main(int argc, char *argv[])
+{
+        struct sigaction        sa;
+        char const      *errstr;
+        int     i;
+
+        if (argc != 2)
+                return (1);
+        errno = 0;
+        i = strtonum(argv[1], 0, INT_MAX, &errstr);
+        if (i == 0 && errno != 0) {
+                fprintf(stderr, "%s\n", errstr);
+                return (1);
+        }
+
+        memset(&sa, 0, sizeof sa);
+        sa.sa_handler = &handler;
+        if (sigaction(SIGTERM, &sa, NULL))
+                err(3, "sigaction");
+        garbage();
+        printf("%d\n", sleep(i));
+        return (0);
+}
+
diff --git a/src/regress/lib/libc/sprintf/Makefile b/src/regress/lib/libc/sprintf/Makefile
new file mode 100644
index 0000000000..47bab9cdd3
--- /dev/null
+++ b/src/regress/lib/libc/sprintf/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.1 2003/05/15 04:23:49 deraadt Exp $
+
+NOMAN=
+PROG=sprintf_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+
+run-regress-atexit_test: ${PROG}
+        ./${PROG}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/sprintf/sprintf_test.c b/src/regress/lib/libc/sprintf/sprintf_test.c
new file mode 100644
index 0000000000..61c58f2f09
--- /dev/null
+++ b/src/regress/lib/libc/sprintf/sprintf_test.c
@@ -0,0 +1,102 @@
+/*      $OpenBSD: sprintf_test.c,v 1.4 2004/09/18 19:31:32 otto Exp $ */
+
+/*
+ * Copyright (c) 2003 Theo de Raadt
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    - Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    - 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 COPYRIGHT HOLDERS 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
+ * COPYRIGHT HOLDERS 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.
+ */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+char correct[] =
+        "|xx 01 02 03 04\n"
+        "|xx 05 06 07 08\n"
+        "|xx 09 10 11 12\n"
+        "|xx 13 14 15 16\n"
+        "|xx 17 18 19 20\n"
+        "|xx 21 22 23 24\n"
+        "|xx 25 26 27 28\n"
+        "|xx 29 30 31 32\n"
+        "|xx 33 34 35 36\n"
+        "|xx 37 38 39 40\n"
+        "|xx 41 42 43 44\n"
+        "|xx 45 -1 1 -1 1\n";
+
+char correct2[] =
+        "1 0 -1 1 1 2 1 3 -1 4 1  \n"
+        "1 -1 1 1 -1 1  \n";
+
+int
+main(int argc, char *argv[])
+{
+        char buf[1024];
+        size_t sz1, sz2, sz3, sz4;
+        ptrdiff_t p1, p2, p3, p4;
+
+        /* Test positional arguments */
+        snprintf(buf, sizeof buf,
+            "|xx %1$s %2$s %3$s %4$s\n"
+            "|xx %5$s %6$s %7$s %8$s\n"
+            "|xx %9$s %10$s %11$s %12$s\n"
+            "|xx %13$s %14$s %15$s %16$s\n"
+            "|xx %17$s %18$s %19$s %20$s\n"
+            "|xx %21$s %22$s %23$s %24$s\n"
+            "|xx %25$s %26$s %27$s %28$s\n"
+            "|xx %29$s %30$s %31$s %32$s\n"
+            "|xx %33$s %34$s %35$s %36$s\n"
+            "|xx %37$s %38$s %39$s %40$s\n"
+            "|xx %41$s %42$s %43$s %44$s\n"
+            "|xx %45$d %46$ld %47$lld %48$d %49$lld\n",
+            "01", "02", "03", "04", "05", "06",
+            "07", "08", "09", "10", "11", "12",
+            "13", "14", "15", "16", "17", "18",
+            "19", "20", "21", "22", "23", "24",
+            "25", "26", "27", "28", "29", "30",
+            "31", "32", "33", "34", "35", "36",
+            "37", "38", "39", "40", "41", "42",
+            "43", "44", 45, -1L, 1LL, -1, 1LL
+            );
+
+        if (strcmp(buf, correct) != 0)
+                exit(1);
+
+        sz1 = (size_t)1;
+        sz2 = (size_t)-1;
+        p1 = (ptrdiff_t)1;
+        p2 = (ptrdiff_t)-1;
+        snprintf(buf, sizeof buf,
+                "%zx %d %zd %d %zu %d %tx %d %td %d %tu %zn %tn\n"
+                "%1$zx %3$zd %5$zu %7$tx %9$td %11$tu %14$zn %15$tn\n",
+                sz1, 0, sz2, 1, sz1, 2, p1, 3, p2, 4, p1, &sz3, &p3, &sz4, &p4);
+        if (strcmp(buf, correct2) != 0 || sz3 != 24 || p3 != 25 ||
+            sz4 != 40 || p4 != 41)
+                exit(1);
+        exit(0);
+}
diff --git a/src/regress/lib/libc/stdio_threading/Makefile b/src/regress/lib/libc/stdio_threading/Makefile
new file mode 100644
index 0000000000..e42481afc2
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/Makefile
@@ -0,0 +1,3 @@
+SUBDIR += fopen fread fwrite fgetln fgets fputs
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/stdio_threading/fgetln/Makefile b/src/regress/lib/libc/stdio_threading/fgetln/Makefile
new file mode 100644
index 0000000000..cad51e2b23
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fgetln/Makefile
@@ -0,0 +1,6 @@
+TOPDIR=${.CURDIR}
+PROG=fgetln_test
+CFLAGS+=-I${TOPDIR}/../include/
+LDFLAGS+=-lpthread
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/stdio_threading/fgetln/fgetln_test.c b/src/regress/lib/libc/stdio_threading/fgetln/fgetln_test.c
new file mode 100755
index 0000000000..d5c4db2edf
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fgetln/fgetln_test.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2008 Bret S. Lambert <blambert@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "local.h"
+
+void
+fgetln_thread(void *v)
+{
+        FILE *file = v;
+        size_t len;
+        char *buf;
+        int i;
+
+        for (i = 0; i < 4096; i++) {
+                if ((buf = fgetln(file, &len)) == NULL) {
+
+                        if (feof(file))
+                                break;
+
+                        printf("OMG!!!\n");
+                        fflush(stdout);
+                        break;
+                }
+                if (strncmp(buf, TEXT_N, sizeof(TEXT_N)))
+                        err(1, "fgetln not atomic!!!");
+        }
+}
+
+int
+main(void)
+{
+        char sfn[24];
+        char buf[sizeof(TEXT_N)];
+        FILE *sfp;
+        int fd, i;
+
+        strlcpy(sfn, "/tmp/barnacles.XXXXXXXX", sizeof(sfn));
+        if ((fd = mkstemp(sfn)) == -1 ||
+            (sfp = fdopen(fd, "w+")) == NULL) {
+                if (fd != -1) {
+                        unlink(sfn);
+                        close(fd);
+                }
+                err(1, "could not open temporary file");
+        }
+
+        for (i = 0; i < 4096 * THREAD_COUNT; i++)
+                if (fwrite(TEXT_N, sizeof(char), strlen(TEXT_N), sfp) == 0)
+                        err(1, "Could not populate test file");
+
+        run_threads(fgetln_thread, sfp);
+
+        unlink(sfn);
+        close(fd);
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/stdio_threading/fgets/Makefile b/src/regress/lib/libc/stdio_threading/fgets/Makefile
new file mode 100644
index 0000000000..52310fd429
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fgets/Makefile
@@ -0,0 +1,6 @@
+TOPDIR=${.CURDIR}
+PROG=fgets_test
+CFLAGS+=-I${TOPDIR}/../include/
+LDFLAGS+=-lpthread
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/stdio_threading/fgets/fgets_test.c b/src/regress/lib/libc/stdio_threading/fgets/fgets_test.c
new file mode 100755
index 0000000000..685d4c8257
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fgets/fgets_test.c
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2008 Bret S. Lambert <blambert@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "local.h"
+
+void
+fgets_thread(void *v)
+{
+        char buf[sizeof(TEXT_N) + 1];
+        FILE *file = v;
+        int i;
+
+        for (i = 0; i < 4096; i++) {
+                if (fgets(buf, sizeof(buf), file) == NULL) {
+
+                        if (feof(file))
+                                break;
+
+                        printf("OMG!!!\n");
+                        fflush(stdout);
+                        break;
+                }
+                if (strncmp(buf, TEXT, sizeof(TEXT)))
+                        err(1, "Read not atomic!!!");
+        }
+}
+
+int
+main(void)
+{
+        char sfn[24];
+        char buf[sizeof(TEXT)];
+        FILE *sfp;
+        int fd, i;
+
+        strlcpy(sfn, "/tmp/barnacles.XXXXXXXX", sizeof(sfn));
+        if ((fd = mkstemp(sfn)) == -1 ||
+            (sfp = fdopen(fd, "w+")) == NULL) {
+                if (fd != -1) {
+                        unlink(sfn);
+                        close(fd);
+                }
+                err(1, "could not open temporary file");
+        }
+
+        for (i = 0; i < 4096 * THREAD_COUNT; i++)
+                if (fwrite(TEXT_N, sizeof(char), strlen(TEXT_N), sfp) == 0)
+                        err(1, "Could not populate test file");
+
+        run_threads(fgets_thread, sfp);
+
+        unlink(sfn);
+        close(fd);
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/stdio_threading/fopen/Makefile b/src/regress/lib/libc/stdio_threading/fopen/Makefile
new file mode 100644
index 0000000000..e51deeff1d
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fopen/Makefile
@@ -0,0 +1,6 @@
+TOPDIR=${.CURDIR}
+PROG=fopen_test
+CFLAGS+=-I${TOPDIR}/../include/
+LDFLAGS+=-lpthread
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/stdio_threading/fopen/fopen_test.c b/src/regress/lib/libc/stdio_threading/fopen/fopen_test.c
new file mode 100755
index 0000000000..72359bb323
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fopen/fopen_test.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2008 Bret S. Lambert <blambert@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <pthread.h>
+#include "local.h"
+
+int
+writefn(void *cookie, const char *buf, int size)
+{
+        return 0;
+}
+
+void
+fopen_thread(void *v)
+{
+        FILE *file;
+        int i;
+
+        for (i = 0; i < 4096; i++) {
+                file = fwopen(&i, writefn);
+                if (file != NULL) {
+                        fputc('0', file);
+                        pthread_yield();
+                        fclose(file);
+                }
+        }
+}
+
+int
+main(void)
+{
+        run_threads(fopen_thread, NULL);
+        exit(0);
+}
diff --git a/src/regress/lib/libc/stdio_threading/fputs/Makefile b/src/regress/lib/libc/stdio_threading/fputs/Makefile
new file mode 100644
index 0000000000..e561745581
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fputs/Makefile
@@ -0,0 +1,6 @@
+TOPDIR=${.CURDIR}
+PROG=fputs_test
+CFLAGS+=-I${TOPDIR}/../include/
+LDFLAGS+=-lpthread
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/stdio_threading/fputs/fputs_test.c b/src/regress/lib/libc/stdio_threading/fputs/fputs_test.c
new file mode 100755
index 0000000000..c0a617510e
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fputs/fputs_test.c
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2008 Bret S. Lambert <blambert@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "local.h"
+
+void
+fputs_thread(void *v)
+{
+        FILE *file = v;
+        int i;
+
+        for (i = 0; i < 4096; i++) {
+                if (fputs(TEXT, file) != 0) {
+
+                        if (feof(file))
+                                break;
+
+                        printf("OMG!!!\n");
+                        fflush(stdout);
+                        break;
+                }
+        }
+}
+
+int
+main(void)
+{
+        char sfn[24];
+        char buf[sizeof(TEXT)];
+        FILE *sfp;
+        int fd, i;
+
+        strlcpy(sfn, "/tmp/barnacles.XXXXXXXX", sizeof(sfn));
+        if ((fd = mkstemp(sfn)) == -1 ||
+            (sfp = fdopen(fd, "w+")) == NULL) {
+                if (fd != -1) {
+                        unlink(sfn);
+                        close(fd);
+                }
+                err(1, "could not open temporary file");
+        }
+
+        run_threads(fputs_thread, sfp);
+
+        while (fgets(buf, sizeof(buf), sfp) != NULL)            /* verify */
+                if (strcmp(buf, TEXT))
+                        err(1, "Thread writes were not atomic!!!");
+
+        unlink(sfn);
+        close(fd);
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/stdio_threading/fread/Makefile b/src/regress/lib/libc/stdio_threading/fread/Makefile
new file mode 100644
index 0000000000..25196dd7ab
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fread/Makefile
@@ -0,0 +1,6 @@
+TOPDIR=${.CURDIR}
+PROG=fread_test
+CFLAGS+=-I${TOPDIR}/../include/
+LDFLAGS+=-lpthread
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/stdio_threading/fread/fread_test.c b/src/regress/lib/libc/stdio_threading/fread/fread_test.c
new file mode 100755
index 0000000000..b2372f5ab6
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fread/fread_test.c
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2008 Bret S. Lambert <blambert@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <pthread.h>
+#include "local.h"
+
+void
+fread_thread(void *v)
+{
+        char buf[sizeof(TEXT)];
+        FILE *file = v;
+        int i;
+
+        for (i = 0; i < 4096; i++) {
+                if (fread(buf, sizeof(char), strlen(TEXT), file) == 0) {
+
+                        if (feof(file))
+                                break;
+
+                        printf("OMG!!!\n");
+                        fflush(stdout);
+                        break;
+                }
+                if (strncmp(buf, TEXT, sizeof(TEXT)))
+                        err(1, "Read not atomic!!!");
+        }
+}
+
+int
+main(void)
+{
+        char sfn[24];
+        char buf[sizeof(TEXT)];
+        FILE *sfp;
+        int fd, i;
+
+        strlcpy(sfn, "/tmp/barnacles.XXXXXXXX", sizeof(sfn));
+        if ((fd = mkstemp(sfn)) == -1 ||
+            (sfp = fdopen(fd, "w+")) == NULL) {
+                if (fd != -1) {
+                        unlink(sfn);
+                        close(fd);
+                }
+                err(1, "could not open temporary file");
+        }
+
+        for (i = 0; i < 4096 * THREAD_COUNT; i++)
+                if (fwrite(TEXT, sizeof(char), strlen(TEXT), sfp) == 0)
+                        err(1, "Could not populate test file");
+
+        run_threads(fread_thread, sfp);
+
+        unlink(sfn);
+        close(fd);
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/stdio_threading/fwrite/Makefile b/src/regress/lib/libc/stdio_threading/fwrite/Makefile
new file mode 100644
index 0000000000..e79899c475
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fwrite/Makefile
@@ -0,0 +1,6 @@
+TOPDIR=${.CURDIR}
+PROG=fwrite_test
+CFLAGS+=-I${TOPDIR}/../include/
+LDFLAGS+=-lpthread
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/stdio_threading/fwrite/fwrite_test.c b/src/regress/lib/libc/stdio_threading/fwrite/fwrite_test.c
new file mode 100755
index 0000000000..39bfb51ef0
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/fwrite/fwrite_test.c
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2008 Bret S. Lambert <blambert@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "local.h"
+
+void
+fwrite_thread(void *v)
+{
+        FILE *file = v;
+        int i;
+
+        for (i = 0; i < 4096; i++) {
+                if (fwrite(TEXT, sizeof(char), strlen(TEXT), file) == 0) {
+
+                        if (feof(file))
+                                break;
+
+                        printf("OMG!!!\n");
+                        fflush(stdout);
+                        break;
+                }
+        }
+}
+
+int
+main(void)
+{
+        char sfn[24];
+        char buf[sizeof(TEXT)];
+        FILE *sfp;
+        int fd, i;
+
+        strlcpy(sfn, "/tmp/barnacles.XXXXXXXX", sizeof(sfn));
+        if ((fd = mkstemp(sfn)) == -1 ||
+            (sfp = fdopen(fd, "w+")) == NULL) {
+                if (fd != -1) {
+                        unlink(sfn);
+                        close(fd);
+                }
+                err(1, "could not open temporary file");
+        }
+
+        run_threads(fwrite_thread, sfp);
+
+        while (fread(buf, sizeof(char), strlen(TEXT), sfp))     /* verify */
+                if (strncmp(buf, TEXT, sizeof(TEXT)))
+                        err(1, "Thread writes were not atomic!!!");
+
+        unlink(sfn);
+        close(fd);
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/stdio_threading/include/local.h b/src/regress/lib/libc/stdio_threading/include/local.h
new file mode 100644
index 0000000000..e2ad4e31e0
--- /dev/null
+++ b/src/regress/lib/libc/stdio_threading/include/local.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2008 Bret S. Lambert <blambert@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+
+#define THREAD_COUNT 64
+
+#define TEXT    "barnacles"
+#define TEXT_N  "barnacles\n"
+
+void    run_threads(void (*)(void *), void *);
+
+static pthread_rwlock_t start;
+static void     (*real_func)(void *);
+
+static void *
+thread(void *arg)
+{
+        int     r;
+
+        if ((r = pthread_rwlock_rdlock(&start)))
+                errx(1, "could not obtain lock in thread: %s", strerror(r));
+        real_func(arg);
+        if ((r = pthread_rwlock_unlock(&start)))
+                errx(1, "could not release lock in thread: %s", strerror(r));
+        return NULL;
+}
+
+void
+run_threads(void (*func)(void *), void *arg)
+{
+        pthread_t       self, pthread[THREAD_COUNT];
+        int     i, r;
+
+        self = pthread_self();
+        real_func = func;
+        if ((r = pthread_rwlock_init(&start, NULL)))
+                errx(1, "could not initialize lock: %s", strerror(r));
+
+        if ((r = pthread_rwlock_wrlock(&start)))                /* block */
+                errx(1, "could not lock lock: %s", strerror(r));
+
+        for (i = 0; i < THREAD_COUNT; i++)
+                if ((r = pthread_create(&pthread[i], NULL, thread, arg))) {
+                        warnx("could not create thread: %s", strerror(r));
+                        pthread[i] = self;
+                }
+
+
+        if ((r = pthread_rwlock_unlock(&start)))                /* unleash */
+                errx(1, "could not release lock: %s", strerror(r));
+
+        sleep(1);
+
+        if ((r = pthread_rwlock_wrlock(&start)))                /* sync */
+                errx(1, "parent could not sync with children: %s",
+                    strerror(r));
+
+        for (i = 0; i < THREAD_COUNT; i++)
+                if (! pthread_equal(pthread[i], self) &&
+                    (r = pthread_join(pthread[i], NULL)))
+                        warnx("could not join thread: %s", strerror(r));
+}
+
diff --git a/src/regress/lib/libc/strerror/Makefile b/src/regress/lib/libc/strerror/Makefile
new file mode 100644
index 0000000000..448b6da903
--- /dev/null
+++ b/src/regress/lib/libc/strerror/Makefile
@@ -0,0 +1,12 @@
+#       $OpenBSD: Makefile,v 1.1 2004/04/30 17:15:12 espie Exp $
+
+NOMAN=
+PROG=strerror_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+CLEANFILES+= invalid.out valid.out
+
+run-regress-strerror_test: ${PROG}
+        ./${PROG} >${.OBJDIR}/valid.out
+        cmp -s ${.OBJDIR}/valid.out ${.CURDIR}/valid.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/strerror/strerror_test.c b/src/regress/lib/libc/strerror/strerror_test.c
new file mode 100644
index 0000000000..700080cd3e
--- /dev/null
+++ b/src/regress/lib/libc/strerror/strerror_test.c
@@ -0,0 +1,71 @@
+/* $OpenBSD: strerror_test.c,v 1.4 2005/05/13 07:06:20 otto Exp $ */
+/*
+ * Copyright (c) 2004 Marc Espie <espie@cvs.openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
+#include <limits.h>
+#include <errno.h>
+
+void
+check_strerror_r(int val)
+{
+        char buffer[NL_TEXTMAX + 1];
+        int i, r;
+
+        memset(buffer, 'X', sizeof(buffer) - 1);
+        buffer[sizeof(buffer) - 1] = '\0';
+        (void)strerror_r(val, NULL, 0); /* XXX */
+        for (i = 0; i < 25; i++) {
+                r = strerror_r(val, buffer, i);
+                printf("%d %d %zu: %s\n", i, r, strlen(buffer), buffer);
+        }
+}
+
+void
+check_strsignal(int val)
+{
+        char buffer[NL_TEXTMAX + 1];
+        int i, r;
+
+        memset(buffer, 'X', sizeof(buffer) - 1);
+        buffer[sizeof(buffer) - 1] = '\0';
+        (void)__strsignal(val, buffer);
+        printf("%s\n", buffer);
+}
+
+int 
+main()
+{
+        printf("%s\n", strerror(21345));
+        printf("%s\n", strerror(-21345));
+        printf("%s\n", strerror(0));
+        printf("%s\n", strerror(INT_MAX));
+        printf("%s\n", strerror(INT_MIN));
+        printf("%s\n", strerror(EPERM));
+        check_strerror_r(EPERM);
+        check_strerror_r(21345);
+        check_strsignal(-1);
+        check_strsignal(0);
+        check_strsignal(10);
+        check_strsignal(NSIG-1);
+        check_strsignal(NSIG);
+        check_strsignal(100);
+        check_strsignal(INT_MAX);
+        check_strsignal(INT_MIN);
+        check_strsignal(UINT_MAX);
+        return 0;
+}
diff --git a/src/regress/lib/libc/strerror/valid.ok b/src/regress/lib/libc/strerror/valid.ok
new file mode 100644
index 0000000000..cbc365c598
--- /dev/null
+++ b/src/regress/lib/libc/strerror/valid.ok
@@ -0,0 +1,65 @@
+Unknown error: 21345
+Unknown error: -21345
+Undefined error: 0
+Unknown error: 2147483647
+Unknown error: -2147483648
+Operation not permitted
+0 34 255: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+1 34 0: 
+2 34 1: O
+3 34 2: Op
+4 34 3: Ope
+5 34 4: Oper
+6 34 5: Opera
+7 34 6: Operat
+8 34 7: Operati
+9 34 8: Operatio
+10 34 9: Operation
+11 34 10: Operation 
+12 34 11: Operation n
+13 34 12: Operation no
+14 34 13: Operation not
+15 34 14: Operation not 
+16 34 15: Operation not p
+17 34 16: Operation not pe
+18 34 17: Operation not per
+19 34 18: Operation not perm
+20 34 19: Operation not permi
+21 34 20: Operation not permit
+22 34 21: Operation not permitt
+23 34 22: Operation not permitte
+24 0 23: Operation not permitted
+0 34 255: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+1 34 0: 
+2 34 1: U
+3 34 2: Un
+4 34 3: Unk
+5 34 4: Unkn
+6 34 5: Unkno
+7 34 6: Unknow
+8 34 7: Unknown
+9 34 8: Unknown 
+10 34 9: Unknown e
+11 34 10: Unknown er
+12 34 11: Unknown err
+13 34 12: Unknown erro
+14 34 13: Unknown error
+15 34 14: Unknown error:
+16 34 15: Unknown error: 
+17 34 15: Unknown error: 
+18 34 15: Unknown error: 
+19 34 15: Unknown error: 
+20 34 15: Unknown error: 
+21 22 20: Unknown error: 21345
+22 22 20: Unknown error: 21345
+23 22 20: Unknown error: 21345
+24 22 20: Unknown error: 21345
+Unknown signal: 4294967295
+Signal 0
+Bus error
+Thread AST
+Unknown signal: 33
+Unknown signal: 100
+Unknown signal: 2147483647
+Unknown signal: 2147483648
+Unknown signal: 4294967295
diff --git a/src/regress/lib/libc/strnlen/Makefile b/src/regress/lib/libc/strnlen/Makefile
new file mode 100644
index 0000000000..e7c74972e1
--- /dev/null
+++ b/src/regress/lib/libc/strnlen/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2010/06/02 12:20:47 millert Exp $
+
+PROG=   strnlentest
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/strnlen/strnlentest.c b/src/regress/lib/libc/strnlen/strnlentest.c
new file mode 100644
index 0000000000..e67e6adfb8
--- /dev/null
+++ b/src/regress/lib/libc/strnlen/strnlentest.c
@@ -0,0 +1,69 @@
+/*      $OpenBSD: strnlentest.c,v 1.1 2010/06/02 12:20:47 millert Exp $ */
+
+/*
+ * Copyright (c) 2010 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+int main(int argc, char *argv[])
+{
+        char *buf;
+        int failures = 0;
+        size_t len, bufsize;
+
+        /* Enable malloc security options. */
+        setenv("MALLOC_OPTIONS", "S", 0);
+
+        bufsize = getpagesize(); /* trigger guard pages easily */
+        buf = malloc(bufsize);
+        if (buf == NULL) {
+                fprintf(stderr, "unable to allocate memory\n");
+                return 1;
+        }
+        memset(buf, 'a', bufsize);
+
+        len = strnlen(buf, bufsize);
+        if (len != bufsize) {
+                fprintf(stderr, "strnlen: failed unterminated buffer test (1)");
+                failures++;
+        }
+
+        len = strnlen(buf, bufsize / 2);
+        if (len != bufsize / 2) {
+                fprintf(stderr, "strnlen: failed unterminated buffer test (2)");
+                failures++;
+        }
+
+        buf[bufsize - 1] = '\0';
+        len = strnlen(buf, bufsize);
+        if (len != bufsize - 1) {
+                fprintf(stderr, "strnlen: failed NUL-terminated buffer test (1)");
+                failures++;
+        }
+
+        len = strnlen(buf, (size_t)-1);
+        if (len != bufsize - 1) {
+                fprintf(stderr, "strnlen: failed NUL-terminated buffer test (2)");
+                failures++;
+        }
+
+        return failures;
+}
diff --git a/src/regress/lib/libc/strtod/Makefile b/src/regress/lib/libc/strtod/Makefile
new file mode 100644
index 0000000000..030c0e7f56
--- /dev/null
+++ b/src/regress/lib/libc/strtod/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/09/29 11:00:24 otto Exp $
+
+PROG=   strtodtest
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/strtod/strtodtest.c b/src/regress/lib/libc/strtod/strtodtest.c
new file mode 100644
index 0000000000..0291365a75
--- /dev/null
+++ b/src/regress/lib/libc/strtod/strtodtest.c
@@ -0,0 +1,22 @@
+/*      $OpenBSD: strtodtest.c,v 1.1 2006/09/29 11:00:24 otto Exp $     */
+/* Public domain, Otto Moerbeek <otto@drijf.net>, 2006. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+/*
+ * Checks if strtod() reports underflow.
+ */
+
+int
+main()
+{
+        char *tmp="0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002";
+        double d;
+
+        d = strtod(tmp, NULL);
+        if (errno != ERANGE)
+                errx(1, "errno = %d", errno);
+        return (0);
+}
diff --git a/src/regress/lib/libc/strtonum/Makefile b/src/regress/lib/libc/strtonum/Makefile
new file mode 100644
index 0000000000..e0e8ecd139
--- /dev/null
+++ b/src/regress/lib/libc/strtonum/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2004/08/03 20:38:36 otto Exp $
+
+PROG=   strtonumtest
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/strtonum/strtonumtest.c b/src/regress/lib/libc/strtonum/strtonumtest.c
new file mode 100644
index 0000000000..7e82a007fe
--- /dev/null
+++ b/src/regress/lib/libc/strtonum/strtonumtest.c
@@ -0,0 +1,64 @@
+/*      $OpenBSD: strtonumtest.c,v 1.1 2004/08/03 20:38:36 otto Exp $   */
+/*
+ * Copyright (c) 2004 Otto Moerbeek <otto@drijf.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int fail;
+
+void
+test(const char *p, long long lb, long long ub, int ok)
+{
+        long long val;
+        const char *q;
+
+        val = strtonum(p, lb, ub, &q);
+        if (ok && q != NULL) {
+                fprintf(stderr, "%s [%lld-%lld] ", p, lb, ub);
+                fprintf(stderr, "NUMBER NOT ACCEPTED %s\n", q);
+                fail = 1;
+        } else if (!ok && q == NULL) {
+                fprintf(stderr, "%s [%lld-%lld] %lld ", p, lb, ub, val);
+                fprintf(stderr, "NUMBER ACCEPTED\n");
+                fail = 1;
+        }
+}
+
+int main(int argc, char *argv[])
+{
+        test("1", 0, 10, 1);
+        test("0", -2, 5, 1);
+        test("0", 2, 5, 0);
+        test("0", 2, LLONG_MAX, 0);
+        test("-2", 0, LLONG_MAX, 0);
+        test("0", -5, LLONG_MAX, 1);
+        test("-3", -3, LLONG_MAX, 1);
+        test("-9223372036854775808", LLONG_MIN, LLONG_MAX, 1);
+        test("9223372036854775807", LLONG_MIN, LLONG_MAX, 1);
+        test("-9223372036854775809", LLONG_MIN, LLONG_MAX, 0);
+        test("9223372036854775808", LLONG_MIN, LLONG_MAX, 0);
+        test("1000000000000000000000000", LLONG_MIN, LLONG_MAX, 0);
+        test("-1000000000000000000000000", LLONG_MIN, LLONG_MAX, 0);
+        test("-2", 10, -1, 0);
+        test("-2", -10, -1, 1);
+        test("-20", -10, -1, 0);
+        test("20", -10, -1, 0);
+
+        return (fail);
+}
+
diff --git a/src/regress/lib/libc/telldir/Makefile b/src/regress/lib/libc/telldir/Makefile
new file mode 100644
index 0000000000..0927779663
--- /dev/null
+++ b/src/regress/lib/libc/telldir/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/03/25 20:27:11 otto Exp $
+
+PROG=   telldir
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/telldir/telldir.c b/src/regress/lib/libc/telldir/telldir.c
new file mode 100644
index 0000000000..fc1ca3e891
--- /dev/null
+++ b/src/regress/lib/libc/telldir/telldir.c
@@ -0,0 +1,106 @@
+/*      $OpenBSD: telldir.c,v 1.2 2006/04/01 18:24:53 otto Exp $        */
+
+/*      Written by Otto Moerbeek, 2006,  Public domain. */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <err.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+
+#define NFILES 1000
+
+void
+createfiles(void)
+{
+        int i, fd;
+        char file[PATH_MAX];
+
+        mkdir("d", 0755);
+        for (i = 0; i < NFILES; i++) {
+                snprintf(file, sizeof file, "d/%d", i);
+                if ((fd = open(file, O_CREAT | O_WRONLY, 0600)) == -1)
+                        err(1, "open %s", file);
+                close(fd);
+        }
+}
+
+void
+delfiles(void)
+{
+        DIR *dp;
+        struct dirent *f;
+        char file[PATH_MAX];
+
+        dp = opendir("d");
+        if (dp == NULL)
+                err(1, "opendir");
+        while (f = readdir(dp)) {
+                if (strcmp(f->d_name, ".") == 0 ||
+                    strcmp(f->d_name, "..") == 0)
+                        continue;
+                snprintf(file, sizeof file, "d/%s", f->d_name);
+                if (unlink(file) == -1)
+                        err(1, "unlink %s", f->d_name);
+        }
+        closedir(dp);
+        if (rmdir("d") == -1)
+                err(1, "rmdir");
+}
+
+void
+loop(DIR *dp, int i)
+{
+        struct dirent *f;
+        char file[PATH_MAX];
+        long pos, remember = -1;
+
+        rewinddir(dp);
+        snprintf(file, sizeof file, "%d", i);
+        for (;;) {
+                pos = telldir(dp);
+                f = readdir(dp);
+                if (f == NULL)
+                        break;
+                if (strcmp(file, f->d_name) == 0)
+                        remember = pos;
+        }
+        if (remember == -1)
+                errx(1, "remember");
+        seekdir(dp, remember);
+        if (telldir(dp) != remember)
+                errx(1, "tell after seek");
+        if (telldir(dp) != remember)
+                errx(1, "tell after tell");
+        f = readdir(dp);
+        if (f == NULL)
+                err(1, "seek to %s %ld", file, remember);
+
+        if (strcmp(f->d_name, file) != 0)
+                err(1, "name mismatch: %s != %s\n", f->d_name, file);
+}
+
+int
+main(void)
+{
+        DIR *dp;
+        int i;
+
+        createfiles();
+
+        dp = opendir("d");
+        if (dp == NULL)
+                err(1, "opendir");
+
+        for (i = 0; i < NFILES; i++)
+                loop(dp, (i + NFILES/2) % NFILES);
+
+        closedir(dp);
+        delfiles();
+        return 0;
+}
diff --git a/src/regress/lib/libc/time/Makefile b/src/regress/lib/libc/time/Makefile
new file mode 100644
index 0000000000..28b5556027
--- /dev/null
+++ b/src/regress/lib/libc/time/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2004/01/20 16:47:55 millert Exp $
+
+SUBDIR+=strptime
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/time/strptime/Makefile b/src/regress/lib/libc/time/strptime/Makefile
new file mode 100644
index 0000000000..f2c9ebaf2c
--- /dev/null
+++ b/src/regress/lib/libc/time/strptime/Makefile
@@ -0,0 +1,12 @@
+#       $OpenBSD: Makefile,v 1.2 2004/01/21 18:13:48 david Exp $
+
+PROG=           strptime_test
+SRCS=           main.c
+CLEANFILES+=    got
+
+REGRESS_TARGETS=do-reg
+do-reg: ${PROG}
+        ./${PROG} < ${.CURDIR}/tests > got
+        diff ${.CURDIR}/expected got
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/time/strptime/expected b/src/regress/lib/libc/time/strptime/expected
new file mode 100644
index 0000000000..d038d319af
--- /dev/null
+++ b/src/regress/lib/libc/time/strptime/expected
@@ -0,0 +1,346 @@
+--- ctime --- 1
+succeeded
+46 27 23 20 0 98 2 -1
+
+--- ctime --- 2
+succeeded
+46 27 23 20 0 98 2 -1
+
+--- ctime --- 3
+succeeded
+46 27 23 20 0 98 2 -1
+
+--- %a --- 1
+succeeded
+-1 -1 -1 -1 -1 -1 0 -1
+
+--- %a --- 2
+succeeded
+-1 -1 -1 -1 -1 -1 0 -1
+
+--- %a --- 3
+succeeded
+-1 -1 -1 -1 -1 -1 1 -1
+
+--- %a --- 4
+succeeded
+-1 -1 -1 -1 -1 -1 1 -1
+
+--- %a --- 5
+succeeded
+-1 -1 -1 -1 -1 -1 2 -1
+
+--- %a --- 6
+succeeded
+-1 -1 -1 -1 -1 -1 2 -1
+
+--- %a --- 7
+succeeded
+-1 -1 -1 -1 -1 -1 3 -1
+
+--- %a --- 8
+succeeded
+-1 -1 -1 -1 -1 -1 3 -1
+
+--- %a --- 9
+succeeded
+-1 -1 -1 -1 -1 -1 4 -1
+
+--- %a --- 10
+succeeded
+-1 -1 -1 -1 -1 -1 4 -1
+
+--- %a --- 11
+succeeded
+-1 -1 -1 -1 -1 -1 5 -1
+
+--- %a --- 12
+succeeded
+-1 -1 -1 -1 -1 -1 5 -1
+
+--- %a --- 13
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+
+--- %a --- 14
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+
+--- %a --- 15
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+urn
+
+--- %a --- 16
+failed
+--- %A --- 1
+succeeded
+-1 -1 -1 -1 -1 -1 0 -1
+
+--- %A --- 2
+succeeded
+-1 -1 -1 -1 -1 -1 0 -1
+
+--- %A --- 3
+succeeded
+-1 -1 -1 -1 -1 -1 1 -1
+
+--- %A --- 4
+succeeded
+-1 -1 -1 -1 -1 -1 1 -1
+
+--- %A --- 5
+succeeded
+-1 -1 -1 -1 -1 -1 2 -1
+
+--- %A --- 6
+succeeded
+-1 -1 -1 -1 -1 -1 2 -1
+
+--- %A --- 7
+succeeded
+-1 -1 -1 -1 -1 -1 3 -1
+
+--- %A --- 8
+succeeded
+-1 -1 -1 -1 -1 -1 3 -1
+
+--- %A --- 9
+succeeded
+-1 -1 -1 -1 -1 -1 4 -1
+
+--- %A --- 10
+succeeded
+-1 -1 -1 -1 -1 -1 4 -1
+
+--- %A --- 11
+succeeded
+-1 -1 -1 -1 -1 -1 5 -1
+
+--- %A --- 12
+succeeded
+-1 -1 -1 -1 -1 -1 5 -1
+
+--- %A --- 13
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+
+--- %A --- 14
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+
+--- %A --- 15
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+urn
+
+--- %A --- 16
+failed
+--- %b --- 1
+succeeded
+-1 -1 -1 -1 0 -1 -1 -1
+
+--- %b --- 2
+succeeded
+-1 -1 -1 -1 0 -1 -1 -1
+
+--- %b --- 3
+succeeded
+-1 -1 -1 -1 1 -1 -1 -1
+
+--- %b --- 4
+succeeded
+-1 -1 -1 -1 1 -1 -1 -1
+
+--- %b --- 5
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+
+--- %b --- 6
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+
+--- %b --- 7
+succeeded
+-1 -1 -1 -1 3 -1 -1 -1
+
+--- %b --- 8
+succeeded
+-1 -1 -1 -1 3 -1 -1 -1
+
+--- %b --- 9
+succeeded
+-1 -1 -1 -1 4 -1 -1 -1
+
+--- %b --- 10
+succeeded
+-1 -1 -1 -1 5 -1 -1 -1
+
+--- %b --- 11
+succeeded
+-1 -1 -1 -1 5 -1 -1 -1
+
+--- %b --- 12
+succeeded
+-1 -1 -1 -1 6 -1 -1 -1
+
+--- %b --- 13
+succeeded
+-1 -1 -1 -1 6 -1 -1 -1
+
+--- %b --- 14
+succeeded
+-1 -1 -1 -1 7 -1 -1 -1
+
+--- %b --- 15
+succeeded
+-1 -1 -1 -1 7 -1 -1 -1
+
+--- %b --- 16
+succeeded
+-1 -1 -1 -1 8 -1 -1 -1
+
+--- %b --- 17
+succeeded
+-1 -1 -1 -1 8 -1 -1 -1
+
+--- %b --- 18
+succeeded
+-1 -1 -1 -1 9 -1 -1 -1
+
+--- %b --- 19
+succeeded
+-1 -1 -1 -1 9 -1 -1 -1
+
+--- %b --- 20
+succeeded
+-1 -1 -1 -1 10 -1 -1 -1
+
+--- %b --- 21
+succeeded
+-1 -1 -1 -1 10 -1 -1 -1
+
+--- %b --- 22
+succeeded
+-1 -1 -1 -1 11 -1 -1 -1
+
+--- %b --- 23
+succeeded
+-1 -1 -1 -1 11 -1 -1 -1
+
+--- %b --- 25
+succeeded
+-1 -1 -1 -1 4 -1 -1 -1
+or
+
+--- %b --- 24
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+s
+
+--- %b --- 26
+failed
+--- %B --- 1
+succeeded
+-1 -1 -1 -1 0 -1 -1 -1
+
+--- %B --- 2
+succeeded
+-1 -1 -1 -1 0 -1 -1 -1
+
+--- %B --- 3
+succeeded
+-1 -1 -1 -1 1 -1 -1 -1
+
+--- %B --- 4
+succeeded
+-1 -1 -1 -1 1 -1 -1 -1
+
+--- %B --- 5
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+
+--- %B --- 6
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+
+--- %B --- 7
+succeeded
+-1 -1 -1 -1 3 -1 -1 -1
+
+--- %B --- 8
+succeeded
+-1 -1 -1 -1 3 -1 -1 -1
+
+--- %B --- 9
+succeeded
+-1 -1 -1 -1 4 -1 -1 -1
+
+--- %B --- 10
+succeeded
+-1 -1 -1 -1 5 -1 -1 -1
+
+--- %B --- 11
+succeeded
+-1 -1 -1 -1 5 -1 -1 -1
+
+--- %B --- 12
+succeeded
+-1 -1 -1 -1 6 -1 -1 -1
+
+--- %B --- 13
+succeeded
+-1 -1 -1 -1 6 -1 -1 -1
+
+--- %B --- 14
+succeeded
+-1 -1 -1 -1 7 -1 -1 -1
+
+--- %B --- 15
+succeeded
+-1 -1 -1 -1 7 -1 -1 -1
+
+--- %B --- 16
+succeeded
+-1 -1 -1 -1 8 -1 -1 -1
+
+--- %B --- 17
+succeeded
+-1 -1 -1 -1 8 -1 -1 -1
+
+--- %B --- 18
+succeeded
+-1 -1 -1 -1 9 -1 -1 -1
+
+--- %B --- 19
+succeeded
+-1 -1 -1 -1 9 -1 -1 -1
+
+--- %B --- 20
+succeeded
+-1 -1 -1 -1 10 -1 -1 -1
+
+--- %B --- 21
+succeeded
+-1 -1 -1 -1 10 -1 -1 -1
+
+--- %B --- 22
+succeeded
+-1 -1 -1 -1 11 -1 -1 -1
+
+--- %B --- 23
+succeeded
+-1 -1 -1 -1 11 -1 -1 -1
+
+--- %B --- 25
+succeeded
+-1 -1 -1 -1 4 -1 -1 -1
+or
+
+--- %B --- 24
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+s
+
+--- %B --- 26
+failed
diff --git a/src/regress/lib/libc/time/strptime/main.c b/src/regress/lib/libc/time/strptime/main.c
new file mode 100644
index 0000000000..c4e06a9b59
--- /dev/null
+++ b/src/regress/lib/libc/time/strptime/main.c
@@ -0,0 +1,110 @@
+/*      $OpenBSD: main.c,v 1.2 2008/06/26 05:42:05 ray Exp $    */
+/*      $NetBSD: main.c,v 1.4 2002/02/21 07:38:18 itojun Exp $  */
+
+/*-
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * 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 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.
+ */
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+int     main(int, char *[]);
+void    die(void);
+
+void
+die(void)
+{
+
+        if (ferror(stdin))
+                err(1, "fgetln");
+        else
+                errx(1, "input is truncated");
+}
+
+int
+main(int argc, char *argv[])
+{
+        char *p, *title, *buf, *format;
+        size_t len;
+        struct tm tm;
+
+        for (;;) {
+                p = fgetln(stdin, &len);
+                if (p == 0)
+                        die();
+                title = malloc(len + 1);
+                memcpy(title, p, len);
+                title[len] = '\0';
+
+                if (!strcmp(title, "EOF\n"))
+                        return(0);
+                if (title[0] == '#' || title[0] == '\n') {
+                        free(title);
+                        continue;
+                }
+
+                p = fgetln(stdin, &len);
+                if (p == 0)
+                        die();
+                buf = malloc(len + 1);
+                memcpy(buf, p, len);
+                buf[len] = '\0';
+
+                p = fgetln(stdin, &len);
+                if (p == 0)
+                        die();
+                format = malloc(len + 1);
+                memcpy(format, p, len);
+                format[len] = '\0';
+
+                tm.tm_sec = -1;
+                tm.tm_min = -1;
+                tm.tm_hour = -1;
+                tm.tm_mday = -1;
+                tm.tm_mon = -1;
+                tm.tm_year = -1;
+                tm.tm_wday = -1;
+                tm.tm_yday = -1;
+
+                p = strptime(buf, format, &tm);
+
+                printf("%s", title);
+                if (p) {
+                        printf("succeeded\n");
+                        printf("%d %d %d %d %d %d %d %d\n",
+                            tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mday,
+                            tm.tm_mon, tm.tm_year, tm.tm_wday, tm.tm_yday);
+                        printf("%s\n", p);
+                } else {
+                        printf("failed\n");
+                }
+
+                free(title);
+                free(buf);
+                free(format);
+        }
+}
diff --git a/src/regress/lib/libc/time/strptime/tests b/src/regress/lib/libc/time/strptime/tests
new file mode 100644
index 0000000000..d96393b2b7
--- /dev/null
+++ b/src/regress/lib/libc/time/strptime/tests
@@ -0,0 +1,267 @@
+# some intial checks to make sure common things work
+--- ctime --- 1
+Tue Jan 20 23:27:46 1998
+%a %b %d %T %Y
+--- ctime --- 2
+Tue Jan 20 23:27:46 1998
+%a %b %d %H:%M:%S %Y
+--- ctime --- 3
+Tue Jan 20 23:27:46 1998
+%c
+
+# test some valid and invalid day names
+--- %a --- 1
+Sun
+%a
+--- %a --- 2
+Sunday
+%a
+--- %a --- 3
+Mon
+%a
+--- %a --- 4
+Monday
+%a
+--- %a --- 5
+Tue
+%a
+--- %a --- 6
+Tuesday
+%a
+--- %a --- 7
+Wed
+%a
+--- %a --- 8
+Wednesday
+%a
+--- %a --- 9
+Thu
+%a
+--- %a --- 10
+Thursday
+%a
+--- %a --- 11
+Fri
+%a
+--- %a --- 12
+Friday
+%a
+--- %a --- 13
+Sat
+%a
+--- %a --- 14
+Saturday
+%a
+--- %a --- 15
+Saturn
+%a
+--- %a --- 16
+Moon
+%a
+--- %A --- 1
+Sun
+%A
+--- %A --- 2
+Sunday
+%A
+--- %A --- 3
+Mon
+%A
+--- %A --- 4
+Monday
+%A
+--- %A --- 5
+Tue
+%A
+--- %A --- 6
+Tuesday
+%A
+--- %A --- 7
+Wed
+%A
+--- %A --- 8
+Wednesday
+%A
+--- %A --- 9
+Thu
+%A
+--- %A --- 10
+Thursday
+%A
+--- %A --- 11
+Fri
+%A
+--- %A --- 12
+Friday
+%A
+--- %A --- 13
+Sat
+%A
+--- %A --- 14
+Saturday
+%A
+--- %A --- 15
+Saturn
+%A
+--- %A --- 16
+Moon
+%A
+
+# test some valid and invalid month names
+--- %b --- 1
+Jan
+%b
+--- %b --- 2
+January
+%b
+--- %b --- 3
+Feb
+%b
+--- %b --- 4
+February
+%b
+--- %b --- 5
+Mar
+%b
+--- %b --- 6
+March
+%b
+--- %b --- 7
+Apr
+%b
+--- %b --- 8
+April
+%b
+--- %b --- 9
+May
+%b
+--- %b --- 10
+Jun
+%b
+--- %b --- 11
+June
+%b
+--- %b --- 12
+Jul
+%b
+--- %b --- 13
+July
+%b
+--- %b --- 14
+Aug
+%b
+--- %b --- 15
+August
+%b
+--- %b --- 16
+Sep
+%b
+--- %b --- 17
+September
+%b
+--- %b --- 18
+Oct
+%b
+--- %b --- 19
+October
+%b
+--- %b --- 20
+Nov
+%b
+--- %b --- 21
+November
+%b
+--- %b --- 22
+Dec
+%b
+--- %b --- 23
+December
+%b
+--- %b --- 25
+Mayor
+%b
+--- %b --- 24
+Mars
+%b
+--- %b --- 26
+Rover
+%b
+--- %B --- 1
+Jan
+%B
+--- %B --- 2
+January
+%B
+--- %B --- 3
+Feb
+%B
+--- %B --- 4
+February
+%B
+--- %B --- 5
+Mar
+%B
+--- %B --- 6
+March
+%B
+--- %B --- 7
+Apr
+%B
+--- %B --- 8
+April
+%B
+--- %B --- 9
+May
+%B
+--- %B --- 10
+Jun
+%B
+--- %B --- 11
+June
+%B
+--- %B --- 12
+Jul
+%B
+--- %B --- 13
+July
+%B
+--- %B --- 14
+Aug
+%B
+--- %B --- 15
+August
+%B
+--- %B --- 16
+Sep
+%B
+--- %B --- 17
+September
+%B
+--- %B --- 18
+Oct
+%B
+--- %B --- 19
+October
+%B
+--- %B --- 20
+Nov
+%B
+--- %B --- 21
+November
+%B
+--- %B --- 22
+Dec
+%B
+--- %B --- 23
+December
+%B
+--- %B --- 25
+Mayor
+%B
+--- %B --- 24
+Mars
+%B
+--- %B --- 26
+Rover
+%B
+EOF
diff --git a/src/regress/lib/libc/vis/Makefile b/src/regress/lib/libc/vis/Makefile
new file mode 100644
index 0000000000..13e560bbf7
--- /dev/null
+++ b/src/regress/lib/libc/vis/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.1 2005/08/29 18:41:56 otto Exp $
+
+PROG=   vis_test
+CLEANFILES+= valid.out
+
+run-regress-vis_test: ${PROG}
+        ./${PROG} >${.OBJDIR}/valid.out
+        cmp -s ${.OBJDIR}/valid.out ${.CURDIR}/valid.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/vis/valid.ok b/src/regress/lib/libc/vis/valid.ok
new file mode 100644
index 0000000000..f8c0efa503
--- /dev/null
+++ b/src/regress/lib/libc/vis/valid.ok
@@ -0,0 +1,2 @@
+\^@\^A\^B\^C\^D\^E\^F\^G\^H     
+\^K\^L\^M\^N\^O\^P\^Q\^R\^S\^T\^U\^V\^W\^X\^Y\^Z\^[\^\\^]\^^\^_ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\^?\M^@\M^A\M^B\M^C\M^D\M^E\M^F\M^G\M^H\M^I\M^J\M^K\M^L\M^M\M^N\M^O\M^P\M^Q\M^R\M^S\M^T\M^U\M^V\M^W\M^X\M^Y\M^Z\M^[\M^\\M^]\M^^\M^_\240\M-!\M-"\M-#\M-$\M-%\M-&\M-'\M-(\M-)\M-*\M-+\M-,\M--\M-.\M-/\M-0\M-1\M-2\M-3\M-4\M-5\M-6\M-7\M-8\M-9\M-:\M-;\M-<\M-=\M->\M-?\M-@\M-A\M-B\M-C\M-D\M-E\M-F\M-G\M-H\M-I\M-J\M-K\M-L\M-M\M-N\M-O\M-P\M-Q\M-R\M-S\M-T\M-U\M-V\M-W\M-X\M-Y\M-Z\M-[\M-\\M-]\M-^\M-_\M-`\M-a\M-b\M-c\M-d\M-e\M-f\M-g\M-h\M-i\M-j\M-k\M-l\M-m\M-n\M-o\M-p\M-q\M-r\M-s\M-t\M-u\M-v\M-w\M-x\M-y\M-z\M-{\M-|\M-}\M-~\M^?
diff --git a/src/regress/lib/libc/vis/vis_test.c b/src/regress/lib/libc/vis/vis_test.c
new file mode 100644
index 0000000000..74113e7a61
--- /dev/null
+++ b/src/regress/lib/libc/vis/vis_test.c
@@ -0,0 +1,109 @@
+/*      $OpenBSD: vis_test.c,v 1.3 2011/03/13 22:12:37 deraadt Exp $    */
+
+/* Public domain. 2005, Otto Moerbeek */
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <vis.h>
+
+#define NTESTS  8000
+#define NCH     800
+
+char ibuf[NCH];
+char obuf[NCH * 4];
+char rbuf[NCH * 4];
+
+int flags[] = {
+        VIS_ALL,
+        VIS_GLOB,
+        VIS_TAB,
+        VIS_NL,
+        VIS_WHITE,
+        VIS_SAFE
+};
+
+char *flagname[] = {
+        "VIS_ALL",
+        "VIS_GLOB",
+        "VIS_TAB",
+        "VIS_NL",
+        "VIS_WHITE",
+        "VIS_SAFE"
+};
+
+int title;
+
+void
+dotitle(int i, int j)
+{
+        if (title == 0)
+                printf("%d %s:", i, flagname[j]);
+        title = 1;
+}
+
+int
+main(int argc, char *argv[])
+{
+
+        char inp[UCHAR_MAX + 1];
+        char out[4 * UCHAR_MAX + 1];
+        int i, j, fail = 0;
+        ssize_t owant, o, r;
+
+        for (i = 0; i <= UCHAR_MAX; i++) {
+                inp[i] = i;
+        }
+        strvisx(out, inp, UCHAR_MAX + 1, 0);
+        printf("%s\n", out);
+
+        for (i = 0; i < NTESTS; i++) {
+                arc4random_buf(ibuf, sizeof(ibuf) - 1);
+                ibuf[sizeof(ibuf) - 1] = '\0';
+                title = 0;
+
+                for (j = 0; j < sizeof(flags)/sizeof(flags[0]); j++) {
+                        owant = sizeof(ibuf);
+                        o = strnvis(obuf, ibuf, owant, flags[j]);
+                        if (o >= owant) {
+                                owant = o + 1;
+                                o = strnvis(obuf, ibuf, owant, flags[j]);
+                                if (o > owant) {
+                                        dotitle(i, j);
+                                        printf("HUGE overflow\n");
+                                }
+                                if (o < owant - 1) {
+                                        dotitle(i, j);
+                                        printf("over-estimate of overflow\n");
+                                }
+                        } else if (o > strlen(ibuf) * 4) {
+                                dotitle(i, j);
+                                printf("wants too much %d %d\n", o, strlen(ibuf) * 4);
+                                continue;
+                        }
+
+                        r = strnunvis(rbuf, obuf, sizeof rbuf);
+
+                        if (r == -1) {
+                                dotitle(i, j);
+                                printf("cannot decode\n");
+                                printf("%s\n", obuf);
+                                fail = 1;
+                        } else if (r != strlen(ibuf)) {
+                                dotitle(i, j);
+                                printf("rlen %d != inlen %d\n", r, strlen(ibuf));
+                                printf("%s\n", obuf);
+                                printf("%s\n", rbuf);
+                                fail = 1;
+                        } else if (bcmp(ibuf, rbuf, r)) {
+                                dotitle(i, j);
+                                printf("strings are different\n");
+                                printf("%s\n", ibuf);
+                                printf("%s\n", rbuf);
+                                fail = 1;
+                        }
+                }
+        }
+        exit(fail);
+}
diff --git a/src/regress/lib/libc/wprintf/Makefile b/src/regress/lib/libc/wprintf/Makefile
new file mode 100644
index 0000000000..7b1897f2c4
--- /dev/null
+++ b/src/regress/lib/libc/wprintf/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2011/04/24 08:00:22 stsp Exp $
+
+PROG=   wfp
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/wprintf/wfp.c b/src/regress/lib/libc/wprintf/wfp.c
new file mode 100644
index 0000000000..fc3120b53c
--- /dev/null
+++ b/src/regress/lib/libc/wprintf/wfp.c
@@ -0,0 +1,218 @@
+/*      $OpenBSD: wfp.c,v 1.1 2011/04/24 08:00:22 stsp Exp $    */
+/*-
+ * Copyright (c) 2002, 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 wprintf() floating point formats.
+ */
+
+#include <assert.h>
+#include <err.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+#define testfmt(result, fmt, ...)       \
+        _testfmt((result), __LINE__, #__VA_ARGS__, fmt, __VA_ARGS__)
+void _testfmt(const wchar_t *, int, const char *, const wchar_t *, ...);
+void smash_stack(void);
+
+int
+main(int argc, char *argv[])
+{
+        /*
+         * Basic tests of decimal output functionality.
+         */
+        testfmt(L" 1.000000E+00", L"%13E", 1.0);
+        testfmt(L"     1.000000", L"%13f", 1.0);
+        testfmt(L"            1", L"%13G", 1.0);
+        testfmt(L" 1.000000E+00", L"%13LE", 1.0L);
+        testfmt(L"     1.000000", L"%13Lf", 1.0L);
+        testfmt(L"            1", L"%13LG", 1.0L);
+
+        testfmt(L"2.718282", L"%.*f", -2, 2.7182818);
+
+        testfmt(L"1.234568e+06", L"%e", 1234567.8);
+        testfmt(L"1234567.800000", L"%f", 1234567.8);
+        testfmt(L"1.23457E+06", L"%G", 1234567.8);
+        testfmt(L"1.234568e+06", L"%Le", 1234567.8L);
+        testfmt(L"1234567.800000", L"%Lf", 1234567.8L);
+        testfmt(L"1.23457E+06", L"%LG", 1234567.8L);
+
+#if (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__)
+        testfmt(L"123456789.864210", L"%Lf", 123456789.8642097531L);
+        testfmt(L"-1.23457E+08", L"%LG", -123456789.8642097531L);
+        testfmt(L"123456789.8642097531", L"%.10Lf", 123456789.8642097531L);
+        testfmt(L" 3.141592653589793238e-4000", L"%L27.18Le",
+            3.14159265358979323846e-4000L);
+#endif /* (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__) */
+
+        /*
+         * Infinities and NaNs
+         */
+#ifdef NAN
+        testfmt(L"nan", L"%e", NAN);
+        testfmt(L"NAN", L"%F", NAN);
+        testfmt(L"nan", L"%g", NAN);
+        testfmt(L"NAN", L"%LE", (long double)NAN);
+        testfmt(L"  nan", L"%05e", NAN);
+#endif /* NAN */
+
+        testfmt(L"INF", L"%E", HUGE_VAL);
+        testfmt(L"-inf", L"%f", -HUGE_VAL);
+        testfmt(L"+inf", L"%+g", HUGE_VAL);
+        testfmt(L" inf", L"%4.2Le", HUGE_VALL);
+        testfmt(L"-inf", L"%Lf", -HUGE_VALL);
+        testfmt(L"  inf", L"%05e", HUGE_VAL);
+        testfmt(L" -inf", L"%05e", -HUGE_VAL);
+
+        /*
+         * Padding
+         */
+        testfmt(L"0.000000e+00", L"%e", 0.0);
+        testfmt(L"0.000000", L"%F", (double)0.0);
+        testfmt(L"0", L"%G", 0.0);
+        testfmt(L"  0", L"%3.0Lg", 0.0L);
+        testfmt(L"    0", L"%5.0f", 0.001);
+
+        /*
+         * Precision specifiers
+         */
+        testfmt(L"1.0123e+00", L"%.4e", 1.0123456789);
+        testfmt(L"1.0123", L"%.4f", 1.0123456789);
+        testfmt(L"1.012", L"%.4g", 1.0123456789);
+        testfmt(L"1.2346e-02", L"%.4e", 0.0123456789);
+        testfmt(L"0.0123", L"%.4f", 0.0123456789);
+        testfmt(L"0.01235", L"%.4g", 0.0123456789);
+
+        /*
+         * Signed conversions
+         */
+        testfmt(L"+2.500000e-01", L"%+e", 0.25);
+        testfmt(L"+0.000000", L"%+F", 0.0);
+        testfmt(L"-1", L"%+g", -1.0);
+
+        testfmt(L"-1.000000e+00", L"% e", -1.0);
+        testfmt(L"+1.000000", L"% +f", 1.0);
+        testfmt(L" 1", L"% g", 1.0);
+        testfmt(L" 0", L"% g", 0.0);
+
+        /*
+         * ``Alternate form''
+         */
+        testfmt(L"1.250e+00", L"%#.3e", 1.25);
+        testfmt(L"123.000000", L"%#f", 123.0);
+        testfmt(L" 12345.", L"%#7.5g", 12345.0);
+        testfmt(L" 1.00000", L"%#8g", 1.0);
+        testfmt(L"0.0", L"%#.2g", 0.0);
+
+        /*
+         * Padding and decimal point placement
+         */
+        testfmt(L"03.2E+00", L"%08.1E", 3.25);
+        testfmt(L"003.25", L"%06.2F", 3.25);
+        testfmt(L"0003.25", L"%07.4G", 3.25);
+
+        testfmt(L"3.14159e-05", L"%g", 3.14159e-5);
+        testfmt(L"0.000314159", L"%g", 3.14159e-4);
+        testfmt(L"3.14159e+06", L"%g", 3.14159e6);
+        testfmt(L"314159", L"%g", 3.14159e5);
+        testfmt(L"314159.", L"%#g", 3.14159e5);
+
+        testfmt(L" 9.000000e+03", L"%13e", 9000.0);
+        testfmt(L" 9000.000000", L"%12f", 9000.0);
+        testfmt(L" 9000", L"%5g", 9000.0);
+        testfmt(L" 900000.", L"%#8g", 900000.0);
+        testfmt(L" 9e+06", L"%6g", 9000000.0);
+        testfmt(L" 9.000000e-04", L"%13e", 0.0009);
+        testfmt(L" 0.000900", L"%9f", 0.0009);
+        testfmt(L" 0.0009", L"%7g", 0.0009);
+        testfmt(L" 9e-05", L"%6g", 0.00009);
+        testfmt(L" 9.00000e-05", L"%#12g", 0.00009);
+        testfmt(L" 9.e-05", L"%#7.1g", 0.00009);
+
+        testfmt(L" 0.0", L"%4.1f", 0.0);
+        testfmt(L"90.0", L"%4.1f", 90.0);
+        testfmt(L" 100", L"%4.0f", 100.0);
+        testfmt(L"9.0e+01", L"%4.1e", 90.0);
+        testfmt(L"1e+02", L"%4.0e", 100.0);
+
+        /*
+         * Hexadecimal floating point (%a, %A) tests.  Some of these
+         * are only valid if the implementation converts to hex digits
+         * on nibble boundaries.
+         */
+        testfmt(L"0x0p+0", L"%a", 0x0.0p0);
+        testfmt(L"0X0.P+0", L"%#LA", 0x0.0p0L);
+#ifdef NAN
+        testfmt(L"inf", L"%La", (long double)INFINITY);
+        testfmt(L"+INF", L"%+A", INFINITY);
+        testfmt(L"nan", L"%La", (long double)NAN);
+        testfmt(L"NAN", L"%A", NAN);
+#endif /* NAN */
+
+        testfmt(L" 0x1.23p+0", L"%10a", 0x1.23p0);
+        testfmt(L" 0x1.23p-500", L"%12a", 0x1.23p-500);
+        testfmt(L" 0x1.2p+40", L"%10.1a", 0x1.23p40);
+        testfmt(L" 0X1.230000000000000000000000P-4", L"%32.24A", 0x1.23p-4);
+        testfmt(L"0x1p-1074", L"%a", 0x1p-1074);
+        testfmt(L"0x1.2345p-1024", L"%a", 0x1.2345p-1024);
+
+        return (0);
+}
+
+void
+smash_stack(void)
+{
+        static uint32_t junk = 0xdeadbeef;
+        uint32_t buf[512];
+        int i;
+
+        for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++)
+                buf[i] = junk;
+}
+
+void
+_testfmt(const wchar_t *result, int line, const char *argstr, const wchar_t *fmt,...)
+{
+        wchar_t s[100];
+        va_list ap;
+
+        va_start(ap, fmt);
+        smash_stack();
+        vswprintf(s, sizeof(s), fmt, ap);
+        if (wcscmp(result, s) != 0) {
+                fprintf(stderr,
+                    "%d: printf(\"%s\", %s) ==> [%s], expected [%s]\n",
+                    line, (char*)fmt, argstr, s, result);
+                abort();
+        }
+}