180 files changed, 19334 insertions, 0 deletions

diff --git a/src/regress/lib/libc/Makefile b/src/regress/lib/libc/Makefile
new file mode 100644
index 0000000000..a0b950033e
--- /dev/null
+++ b/src/regress/lib/libc/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.34 2012/07/11 10:46:23 naddy Exp $
+
+SUBDIR+= _setjmp alloca atexit basename cephes cxa-atexit db dirname env
+SUBDIR+= fnmatch fpclassify getaddrinfo getcap getopt_long glob hsearch
+SUBDIR+= longjmp locale malloc mkstemp netdb orientation popen printf
+SUBDIR+= regex setjmp setjmp-signal sigreturn sigsetjmp sprintf
+SUBDIR+= stdio_threading stpncpy strerror strtod strtonum telldir time vis
+
+.if (${MACHINE_ARCH} != "vax")
+SUBDIR+= ieeefp
+.endif
+
+.if exists(arch/${MACHINE_ARCH})
+SUBDIR+= arch/${MACHINE_ARCH}
+.endif
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/_setjmp/Makefile b/src/regress/lib/libc/_setjmp/Makefile
new file mode 100644
index 0000000000..5d58242523
--- /dev/null
+++ b/src/regress/lib/libc/_setjmp/Makefile
@@ -0,0 +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
+
+CFLAGS+= -DTEST_U_SETJMP
+
+.PATH:  ${.CURDIR}/../setjmp
+
+.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
new file mode 100644
index 0000000000..8c4dfb735c
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/Makefile
@@ -0,0 +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=
+
+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
new file mode 100644
index 0000000000..1da3ac8494
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/divremtest/Makefile
@@ -0,0 +1,30 @@
+#       $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
+NOMAN=
+
+CLEANFILES+=    mkcases cases.c mktestcases testcases
+
+divremtest.c: cases.c
+
+cases.c: mkcases
+        /bin/rm -f cases.c
+        mkcases > cases.c
+
+# a typical strategy to use this:
+# compile a NetBSD divremtest binary, an OSF/1 divremtest binary, and an
+# OSF/1 mktestcases binary.  You then run mktestecases | divremtest -g
+# on an OSF/1 machine, and pipe the output to an rsh to a NetBSD machine
+# which then runs divremtest.  You can test an infinite number of random
+# values that way; I like to put a 'dd' in, so I can see how much I've done.
+
+testcases: mktestcases divremtest
+        /bin/rm -f testcases
+        mktestcases | divremtest -g > testcases
+
+regress:
+        @echo THIS TEST CANNOT BE RUN AUTOMATICALLY.
+        @false
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c b/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
new file mode 100644
index 0000000000..3d9e8a6de2
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
@@ -0,0 +1,184 @@
+/*      $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 $       */
+
+/*
+ * Copyright (c) 1995 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 by Christopher G. Demetriou
+ *      for the NetBSD Project.
+ * 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.
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+
+void    testfile();
+void    usage();
+
+int generate;
+
+int
+main(argc, argv)
+        int argc;
+        char **argv;
+{
+        int c;
+
+        signal(SIGFPE, SIG_IGN);
+
+        while ((c = getopt(argc, argv, "g")) != -1)
+                switch (c) {
+                case 'g':
+                        generate = 1;
+                        break;
+
+                default:
+                        usage();
+                        break;
+        }
+
+        argc -= optind;
+        argv += optind;
+
+        if (argc == 0)
+                testfile();
+        else
+                for (; argc != 0; argc--, argv++) {
+                        if (freopen(argv[0], "r", stdin) == NULL) {
+                                fprintf(stderr,
+                                    "divremtest: couldn't open %s\n",
+                                    argv[0]);
+                                exit(1);
+                        }
+
+                        testfile();
+                }
+
+        exit(0);
+}
+
+void
+testfile()
+{
+        union operand {
+                unsigned long   input;
+                int             op_int;
+                unsigned int    op_u_int;
+                long            op_long;
+                unsigned long   op_u_long;
+        } op1, op2, divres, modres, divwant, modwant;
+        char opspec[6];
+        int encoded, i;
+
+        while (scanf("%6c %lx %lx %lx %lx\n", opspec, &op1.input,
+            &op2.input, &divwant.input, &modwant.input) != EOF) {
+
+                encoded = 0;
+
+                for (i = 0; i < 6; i += 2) {
+                        int posval;
+
+                        switch (opspec[i]) {
+                        case '.':
+                                posval = 0;
+                                break;
+                        case '-':
+                                posval = 1;
+                                break;
+                        default:
+                                fprintf(stderr,
+                                    "unknown signedness spec %c\n",
+                                    opspec[i]);
+                                exit(1);
+                        }
+                        encoded |= posval << ((5 - i) * 4);
+                }
+                        
+                for (i = 1; i < 6; i += 2) {
+                        int posval;
+
+                        switch (opspec[i]) {
+                        case 'i':
+                                posval = 0;
+                                break;
+                        case 'l':
+                                posval = 1;
+                                break;
+                        default:
+                                fprintf(stderr, "unknown length spec %c\n",
+                                    opspec[i]);
+                                exit(1);
+                        }
+                        encoded |= posval << ((5 - i) * 4);
+                }
+
+                /* KILL ME!!! */
+                switch (encoded) {
+
+#define TRY_IT(a, b, c)                                                 \
+        divres.a = op1.b / op2.c;                                       \
+        modres.a = op1.b % op2.c;                                       \
+        if (generate) {                                                 \
+                printf("%6s 0x%016lx 0x%016lx 0x%016lx 0x%016lx\n",     \
+                    opspec, op1.input, op2.input,                       \
+                    divres.a, modres.a);                                \
+        } else {                                                        \
+                if ((divres.a != divwant.a) ||                          \
+                    (modres.a != modwant.a)) {                          \
+                        fprintf(stderr, "%6s 0x%016lx 0x%016lx\n",      \
+                            opspec, op1.input, op2.input);              \
+                        fprintf(stderr, "FAILED:\n");                   \
+                        fprintf(stderr,                                 \
+                            "div:\twanted 0x%16lx, got 0x%16lx\n",      \
+                            divwant.a, divres.a);                       \
+                        fprintf(stderr,                                 \
+                            "mod:\twanted 0x%16lx, got 0x%16lx\n",      \
+                            modwant.a, modres.a);                       \
+                                                                        \
+                        exit(1);                                        \
+                }                                                       \
+        }
+
+#include "cases.c"
+
+#undef TRY_IT
+
+                default:
+                        fprintf(stderr,
+                            "INTERNAL ERROR: unknown encoding %x\n", encoded);
+                        exit(1);
+                }
+        }
+}
+
+void
+usage()
+{
+
+        fprintf(stderr, "usage: divremtest [-v] [testfile ...]\n");
+        exit(1);
+}
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c b/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
new file mode 100644
index 0000000000..fcb4765b8c
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
@@ -0,0 +1,64 @@
+/*      $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 $  */
+
+/*
+ * Copyright (c) 1995 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 by Christopher G. Demetriou
+ *      for the NetBSD Project.
+ * 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.
+ */
+
+char *tab[4] = { "u_int", "int", "u_long", "long" };
+
+int
+main()
+{
+        int i;
+
+        for (i = 0; i < 64; i++) {
+                printf(
+"               case 0x%d%d%d%d%d%d:    /* %s <= %s op %s */\n",
+                        (i >> 5) & 1,
+                        (i >> 4) & 1,
+                        (i >> 3) & 1,
+                        (i >> 2) & 1,
+                        (i >> 1) & 1,
+                        (i >> 0) & 1,
+                        tab[(i >> 4) & 0x3],
+                        tab[(i >> 2) & 0x3],
+                        tab[(i >> 0) & 0x3]);
+                printf(
+"                       TRY_IT(op_%s, op_%s, op_%s);\n",
+                        tab[(i >> 4) & 0x3],
+                        tab[(i >> 2) & 0x3],
+                        tab[(i >> 0) & 0x3]);
+                printf(
+"                       break;\n\n");
+        }
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c b/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
new file mode 100644
index 0000000000..3b01653f32
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
@@ -0,0 +1,68 @@
+/*      $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 $      */
+
+/*
+ * Copyright (c) 1995 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 by Christopher G. Demetriou
+ *      for the NetBSD Project.
+ * 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.
+ */
+
+#include <stdio.h>
+
+int
+main()
+{
+        int i, j;
+        unsigned long n1, n2;
+
+        srandom(time(NULL));
+
+        for (i = 1; /* i < 10240 */ 1; i++) {
+                n1 = (unsigned)
+                    (random() & ((random() & random()) | 0x80000000));
+                n1 <<= 32;
+                n1 |= (unsigned)(random() & random() & random());
+
+                n2 = (unsigned)
+                    (random() & ((random() & random()) | 0x80000000));
+                n2 <<= 32;
+                n2 |= (unsigned)(random() & random() & random());
+
+                for (j = 0; j < 64; j++) {
+                        char *tab[] = { ".i", ".l", "-i", "-l" };
+
+                        printf("%s%s%s 0x%lx 0x%lx 0 0\n",
+                            tab[(j >> 4) & 0x3],
+                            tab[(j >> 2) & 0x3],
+                            tab[(j >> 0) & 0x3],
+                            n1, n2);
+                }
+        }
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/asr/Makefile b/src/regress/lib/libc/asr/Makefile
new file mode 100644
index 0000000000..ac1d4ed18c
--- /dev/null
+++ b/src/regress/lib/libc/asr/Makefile
@@ -0,0 +1,53 @@
+#       $OpenBSD: Makefile,v 1.2 2012/08/07 21:00:31 eric Exp $
+
+#
+# Note on building and running the regress tests:
+#
+# The regress suite builds two sets of static executables: one linked
+# against the current libc, and one linked against a libc with the resolver
+# replaced. The idea is to compare the output of all programs in both cases.
+#
+# So before building the regression test programs, you need to have the two
+# libc.a ready.  By default, it is assumed that the asr-enabled libc was just
+# built from src but not installed, so the current libc.a is expected to be
+# found in /usr/lib, and the new one in /usr/obj/lib/libc. If your setting
+# is different, just set LIBCDIRSTD and LIBCDIRASR accordingly.
+# 
+# When done, run "make && make install". This builds and installs the two sets
+# of programs in REGRESSDIR. They will run chrooted there to allow testing with
+# various /etc environment without messing up the local machine config files.
+#
+# When you are sure everything is in place, run "make regress". This will
+# create two files: $REGRESSDIR/output.log with the output of all run tests,
+# and $REGRESSDIR/regress.log with the diffs for those that "failed".
+#
+# Note that "install" and "regress" targets need to be run as root.
+#
+
+LIBCDIRSTD?=    /usr/lib
+LIBCDIRASR?=    /usr/obj/lib/libc
+
+REGRESSDIR?=    /tmp/regress
+REGRESS?=       regress.sh
+
+all: build
+
+build:
+        cd bin && EXT=.asr LDFLAGS=-L${LIBCDIRASR} make
+        cd bin && EXT=.std LDFLAGS=-L${LIBCDIRSTD} make
+
+clean:
+        cd bin && EXT=.std make clean
+        cd bin && EXT=.asr make clean
+
+install:
+        mkdir -p ${REGRESSDIR}/etc
+        mkdir -p ${REGRESSDIR}/bin
+        cd bin && BINDIR=${REGRESSDIR}/bin EXT=.std make install
+        cd bin && BINDIR=${REGRESSDIR}/bin EXT=.asr make install
+
+uninstall:
+        rm -rf ${REGRESSDIR}
+
+regress:
+        RUNDIR=${REGRESSDIR} sh ${.CURDIR}/${REGRESS}
diff --git a/src/regress/lib/libc/asr/bin/Makefile b/src/regress/lib/libc/asr/bin/Makefile
new file mode 100644
index 0000000000..1f986a8e69
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/Makefile
@@ -0,0 +1,10 @@
+SUBDIR=         res_mkquery
+SUBDIR+=        res_query
+SUBDIR+=        gethostnamadr
+SUBDIR+=        getnetnamadr
+SUBDIR+=        getrrsetbyname
+SUBDIR+=        getnameinfo
+SUBDIR+=        getaddrinfo
+SUBDIR+=        threads
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/asr/bin/Makefile.inc b/src/regress/lib/libc/asr/bin/Makefile.inc
new file mode 100644
index 0000000000..80b4805136
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/Makefile.inc
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile.inc,v 1.2 2012/09/05 21:21:13 eric Exp $
+
+NOMAN=  noman
+
+SRCS+=          common.c
+CFLAGS+=        -Wall -Wstrict-prototypes -Werror -Wundef -g
+LDSTATIC=       ${STATIC}
+PROG:=          ${PROG}${EXT}
diff --git a/src/regress/lib/libc/asr/bin/common.c b/src/regress/lib/libc/asr/bin/common.c
new file mode 100644
index 0000000000..4402d08373
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/common.c
@@ -0,0 +1,633 @@
+/*      $OpenBSD: common.c,v 1.1.1.1 2012/07/13 17:49:53 eric Exp $     */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <err.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "common.h"
+
+int long_err;
+int gai_errno;
+int rrset_errno;
+
+
+char *
+gethostarg(char *n)
+{
+        if (n == NULL)
+                return (n);
+        if (!strcmp(n, "NULL"))
+                return (NULL);
+        if (!strcmp(n, "EMPTY"))
+                return ("");
+        return (n);
+}
+
+const char *rrsetstrerror(int);
+char * print_addr(const struct sockaddr *, char *, size_t);
+
+struct kv { int code; const char *name; };
+
+struct kv kv_family[] = {
+        { AF_UNIX,      "unix" },
+        { AF_INET,      "inet" },
+        { AF_INET6,     "inet6" },
+        { AF_IMPLINK,   "implink" },
+        { AF_BLUETOOTH, "bluetooth" },
+        { 0,    NULL, }
+};
+struct kv kv_socktype[] = {
+        { SOCK_STREAM,  "stream" },
+        { SOCK_DGRAM,   "dgram" },
+        { SOCK_RAW,     "raw" },
+        { 0,    NULL, }
+};
+struct kv kv_protocol[] = {
+        { IPPROTO_UDP, "udp" },
+        { IPPROTO_TCP, "tcp" },
+        { 0,    NULL, }
+};
+
+static const char *
+kv_lookup_name(struct kv *kv, int code)
+{
+        while (kv->name) {
+                if (kv->code == code)
+                        return (kv->name);
+                kv++;
+        }
+        return "???";
+}
+
+struct keyval {
+        const char      *key;
+        uint16_t         value;   
+};
+
+static struct keyval kv_class[] = {
+        { "IN", C_IN },
+        { "CHAOS", C_CHAOS },
+        { "HS", C_HS },
+        { "ANY", C_ANY },
+        { NULL,         0 },
+};
+
+static struct keyval kv_type[] = {
+        { "A",          T_A     },
+        { "NS",         T_NS    },
+        { "MD",         T_MD    },
+        { "MF",         T_MF    },
+        { "CNAME",      T_CNAME },
+        { "SOA",        T_SOA   },
+        { "MB",         T_MB    },
+        { "MG",         T_MG    },
+        { "MR",         T_MR    },
+        { "NULL",       T_NULL  },
+        { "WKS",        T_WKS   },
+        { "PTR",        T_PTR   },
+        { "HINFO",      T_HINFO },
+        { "MINFO",      T_MINFO },
+        { "MX",         T_MX    },
+        { "TXT",        T_TXT   },
+
+        { "AAAA",       T_AAAA  },
+
+        { "AXFR",       T_AXFR  },
+        { "MAILB",      T_MAILB },
+        { "MAILA",      T_MAILA },
+        { "ANY",        T_ANY   },
+        { NULL,         0 },
+};
+
+static struct keyval kv_rcode[] = {
+        { "NOERROR",    NOERROR },
+        { "FORMERR",    FORMERR },
+        { "SERVFAIL",   SERVFAIL },
+        { "NXDOMAIN",   NXDOMAIN },
+        { "NOTIMP",     NOTIMP },
+        { "REFUSED",    REFUSED },
+        { NULL,         0 },
+};
+
+
+const char *
+rcodetostr(uint16_t v)
+{
+        static char     buf[16];
+        size_t          i;
+
+        for(i = 0; kv_rcode[i].key; i++)
+                if (kv_rcode[i].value == v)
+                        return (kv_rcode[i].key);
+
+        snprintf(buf, sizeof buf, "%"PRIu16"?", v);
+
+        return (buf);
+}
+
+const char *
+typetostr(uint16_t v)
+{
+        static char      buf[16];
+        size_t           i;
+
+        for(i = 0; kv_type[i].key; i++)
+                if (kv_type[i].value == v)
+                        return (kv_type[i].key);
+
+        snprintf(buf, sizeof buf, "%"PRIu16"?", v);
+
+        return (buf);
+}
+
+const char *
+classtostr(uint16_t v)
+{
+        static char      buf[16];
+        size_t           i;
+
+        for(i = 0; kv_class[i].key; i++)
+                if (kv_class[i].value == v)
+                        return (kv_class[i].key);
+
+        snprintf(buf, sizeof buf, "%"PRIu16"?", v);
+
+        return (buf);
+}
+
+uint16_t
+strtotype(const char *name)
+{
+        size_t  i;
+
+        for(i = 0; kv_type[i].key; i++)
+                if (!strcmp(kv_type[i].key, name))
+                        return (kv_type[i].value);
+
+        return (0);
+}
+
+uint16_t
+strtoclass(const char *name)
+{
+        size_t  i;
+
+        for(i = 0; kv_class[i].key; i++)
+                if (!strcmp(kv_class[i].key, name))
+                        return (kv_class[i].value);
+
+        return (0);
+}
+
+void
+print_hostent(struct hostent *e)
+{
+        char    buf[256], **c;
+
+        printf("name = \"%s\"\n", e->h_name);
+        printf("aliases =");
+        for(c = e->h_aliases; *c; c++)
+                printf(" \"%s\"", *c);
+        printf("\n");
+        printf("addrtype = %i\n", e->h_addrtype);
+        printf("addrlength = %i\n", e->h_length);
+        printf("addr_list =");
+        for(c = e->h_addr_list; *c; c++) {
+                printf(" %s", inet_ntop(e->h_addrtype, *c, buf, sizeof buf));
+        }
+        printf("\n");
+}
+
+void
+print_netent(struct netent *e)
+{
+        char    buf[256], **c;
+        uint32_t addr;
+
+        /* network number are given in host order */
+        addr = htonl(e->n_net);
+
+        printf("name = \"%s\"\n", e->n_name);
+        printf("aliases =");
+        for (c = e->n_aliases; *c; c++)
+                printf(" \"%s\"", *c);
+        printf("\n");
+        printf("addrtype = %i\n", e->n_addrtype);
+        printf("net = %s\n", inet_ntop(e->n_addrtype, &addr, buf, sizeof buf));
+}
+
+void
+print_addrinfo(struct addrinfo *ai)
+{
+        char    buf[256];
+
+        printf("family=%s socktype=%s protocol=%s addr=%s canonname=%s\n",
+                kv_lookup_name(kv_family, ai->ai_family),
+                kv_lookup_name(kv_socktype, ai->ai_socktype),
+                kv_lookup_name(kv_protocol, ai->ai_protocol),
+                print_addr(ai->ai_addr, buf, sizeof buf),
+                ai->ai_canonname);
+}
+
+const char *
+rrsetstrerror(int e)
+{
+        switch (e) {
+        case 0:
+                return "OK";
+        case ERRSET_NONAME:
+                return "ERRSET_NONAME";
+        case ERRSET_NODATA:
+                return "ERRSET_NODATA";
+        case ERRSET_NOMEMORY:
+                return "ERRSET_NOMEMORY";
+        case ERRSET_INVAL:
+                return "ERRSET_INVAL";
+        case ERRSET_FAIL:
+                return "ERRSET_FAIL";
+        default:
+                return "???";
+        }
+}
+
+void
+print_rrsetinfo(struct rrsetinfo * rrset)
+{
+        printf("rri_flags=%u\n", rrset->rri_flags);
+        printf("rri_rdclass=%u\n", rrset->rri_rdclass);
+        printf("rri_rdtype=%u\n", rrset->rri_rdtype);
+        printf("rri_ttl=%u\n", rrset->rri_ttl);
+        printf("rri_nrdatas=%u\n", rrset->rri_nrdatas);
+        printf("rri_nsigs=%u\n", rrset->rri_nsigs);
+        printf("rri_name=\"%s\"\n", rrset->rri_name);
+}
+
+void
+print_errors(void)
+{
+        switch (long_err) {
+        case 0:
+                return;
+        case 1:
+                printf("  => errno %i, h_errno %i", errno, h_errno);
+                printf(", rrset_errno %i", rrset_errno);
+                printf(", gai_errno %i", gai_errno);
+                printf ("\n");
+                return;
+        default:
+                printf("  => errno %i: %s\n  => h_errno %i: %s\n  => rrset_errno %i: %s\n",
+                    errno, errno ? strerror(errno) : "ok",
+                    h_errno, h_errno ? hstrerror(h_errno) : "ok",
+                    rrset_errno, rrset_errno ? rrsetstrerror(rrset_errno) : "ok");
+                printf("  => gai_errno %i: %s\n",
+                    gai_errno, gai_errno ? gai_strerror(gai_errno) : "ok");
+        }
+}
+
+
+static char *
+print_host(const struct sockaddr *sa, char *buf, size_t len)
+{
+        switch (sa->sa_family) {
+        case AF_INET:
+                inet_ntop(AF_INET, &((struct sockaddr_in*)sa)->sin_addr,
+                          buf, len);
+                break;
+        case AF_INET6:
+                inet_ntop(AF_INET6, &((struct sockaddr_in6*)sa)->sin6_addr,
+                          buf, len);
+                break;
+        default:
+                buf[0] = '\0';
+        }
+        return (buf);
+}
+
+
+char *
+print_addr(const struct sockaddr *sa, char *buf, size_t len)
+{
+        char    h[256];
+
+        print_host(sa, h, sizeof h);
+
+        switch (sa->sa_family) {
+        case AF_INET:
+                snprintf(buf, len, "%s:%i", h,
+                    ntohs(((struct sockaddr_in*)(sa))->sin_port));
+                break;
+        case AF_INET6:
+                snprintf(buf, len, "[%s]:%i", h,
+                    ntohs(((struct sockaddr_in6*)(sa))->sin6_port));
+                break;
+        default:
+                snprintf(buf, len, "?");
+                break;
+        }
+
+        return (buf);
+}
+
+void
+packed_init(struct packed *pack, char *data, size_t len)
+{
+        pack->data = data;
+        pack->len = len;
+        pack->offset = 0;
+        pack->err = NULL;
+}
+
+
+static ssize_t
+dname_expand(const unsigned char *data, size_t len, size_t offset,
+    size_t *newoffset, char *dst, size_t max)
+{
+        size_t           n, count, end, ptr, start;
+        ssize_t          res;
+
+        if (offset >= len)
+                return (-1);
+
+        res = 0;
+        end = start = offset;
+
+        for(; (n = data[offset]); ) {
+                if ((n & 0xc0) == 0xc0) {
+                        if (offset + 2 > len)
+                                return (-1);
+                        ptr = 256 * (n & ~0xc0) + data[offset + 1];
+                        if (ptr >= start)
+                                return (-1);
+                        if (end < offset + 2)
+                                end = offset + 2;
+                        offset = ptr;
+                        continue;
+                }
+                if (offset + n + 1 > len)
+                        return (-1);
+
+
+                /* copy n + at offset+1 */
+                if (dst != NULL && max != 0) {
+                        count = (max < n + 1) ? (max) : (n + 1);
+                        memmove(dst, data + offset, count);
+                        dst += count;
+                        max -= count;
+                }
+                res += n + 1;
+                offset += n + 1;
+                if (end < offset)
+                        end = offset;
+        }
+        if (end < offset + 1)
+                end = offset + 1;
+
+        if (dst != NULL && max != 0)
+                dst[0] = 0;
+        if (newoffset)
+                *newoffset = end;
+        return (res + 1);
+}
+
+static int
+unpack_data(struct packed *p, void *data, size_t len)
+{
+        if (p->err)
+                return (-1);
+
+        if (p->len - p->offset < len) {
+                p->err = "too short";
+                return (-1);
+        }
+
+        memmove(data, p->data + p->offset, len);
+        p->offset += len;
+
+        return (0);
+}
+
+static int
+unpack_u16(struct packed *p, uint16_t *u16)
+{
+        if (unpack_data(p, u16, 2) == -1)
+                return (-1);
+
+        *u16 = ntohs(*u16);
+
+        return (0);
+}
+
+static int
+unpack_u32(struct packed *p, uint32_t *u32)
+{
+        if (unpack_data(p, u32, 4) == -1)
+                return (-1);
+
+        *u32 = ntohl(*u32);
+
+        return (0);
+}
+
+static int
+unpack_inaddr(struct packed *p, struct in_addr *a)
+{
+        return (unpack_data(p, a, 4));
+}
+
+static int
+unpack_in6addr(struct packed *p, struct in6_addr *a6)
+{
+        return (unpack_data(p, a6, 16));
+}
+
+static int
+unpack_dname(struct packed *p, char *dst, size_t max)
+{
+        ssize_t e;
+
+        if (p->err)
+                return (-1);
+
+        e = dname_expand(p->data, p->len, p->offset, &p->offset, dst, max);
+        if (e == -1) {
+                p->err = "bad domain name";
+                return (-1);
+        }
+        if (e < 0 || e > MAXDNAME) {
+                p->err = "domain name too long";
+                return (-1);
+        }
+
+        return (0);
+}
+
+int
+unpack_header(struct packed *p, struct header *h)
+{
+        if (unpack_data(p, h, HFIXEDSZ) == -1)
+                return (-1);
+
+        h->flags = ntohs(h->flags);
+        h->qdcount = ntohs(h->qdcount);
+        h->ancount = ntohs(h->ancount);
+        h->nscount = ntohs(h->nscount);
+        h->arcount = ntohs(h->arcount);
+
+        return (0);
+}
+
+int
+unpack_query(struct packed *p, struct query *q)
+{
+        unpack_dname(p, q->q_dname, sizeof(q->q_dname));
+        unpack_u16(p, &q->q_type);
+        unpack_u16(p, &q->q_class);
+
+        return (p->err) ? (-1) : (0);
+}
+
+int
+unpack_rr(struct packed *p, struct rr *rr)
+{
+        uint16_t        rdlen;
+        size_t          save_offset;
+
+        unpack_dname(p, rr->rr_dname, sizeof(rr->rr_dname));
+        unpack_u16(p, &rr->rr_type);
+        unpack_u16(p, &rr->rr_class);
+        unpack_u32(p, &rr->rr_ttl);
+        unpack_u16(p, &rdlen);
+
+        if (p->err)
+                return (-1);
+
+        if (p->len - p->offset < rdlen) {
+                p->err = "too short";
+                return (-1);
+        }
+
+        save_offset = p->offset;
+
+        switch(rr->rr_type) {
+
+        case T_CNAME:
+                unpack_dname(p, rr->rr.cname.cname, sizeof(rr->rr.cname.cname));
+                break;
+
+        case T_MX:
+                unpack_u16(p, &rr->rr.mx.preference);
+                unpack_dname(p, rr->rr.mx.exchange, sizeof(rr->rr.mx.exchange));
+                break;
+
+        case T_NS:
+                unpack_dname(p, rr->rr.ns.nsname, sizeof(rr->rr.ns.nsname));
+                break;
+
+        case T_PTR:
+                unpack_dname(p, rr->rr.ptr.ptrname, sizeof(rr->rr.ptr.ptrname));
+                break;
+
+        case T_SOA:
+                unpack_dname(p, rr->rr.soa.mname, sizeof(rr->rr.soa.mname));
+                unpack_dname(p, rr->rr.soa.rname, sizeof(rr->rr.soa.rname));
+                unpack_u32(p, &rr->rr.soa.serial);
+                unpack_u32(p, &rr->rr.soa.refresh);
+                unpack_u32(p, &rr->rr.soa.retry);
+                unpack_u32(p, &rr->rr.soa.expire);
+                unpack_u32(p, &rr->rr.soa.minimum);
+                break;
+
+        case T_A:
+                if (rr->rr_class != C_IN)
+                        goto other;
+                unpack_inaddr(p, &rr->rr.in_a.addr);
+                break;
+
+        case T_AAAA:
+                if (rr->rr_class != C_IN)
+                        goto other;
+                unpack_in6addr(p, &rr->rr.in_aaaa.addr6);
+                break;
+        default:
+        other:
+                rr->rr.other.rdata = p->data + p->offset;
+                rr->rr.other.rdlen = rdlen;
+                p->offset += rdlen;
+        }
+
+        if (p->err)
+                return (-1);
+
+        /* make sure that the advertised rdlen is really ok */
+        if (p->offset - save_offset != rdlen)
+                p->err = "bad dlen";
+
+        return (p->err) ? (-1) : (0);
+}
+
+int
+sockaddr_from_str(struct sockaddr *sa, int family, const char *str)
+{
+        struct in_addr           ina;
+        struct in6_addr          in6a;
+        struct sockaddr_in      *sin;
+        struct sockaddr_in6     *sin6;
+
+        switch (family) {
+        case PF_UNSPEC:
+                if (sockaddr_from_str(sa, PF_INET, str) == 0)
+                        return (0);
+                return sockaddr_from_str(sa, PF_INET6, str);
+
+        case PF_INET:
+                if (inet_pton(PF_INET, str, &ina) != 1)
+                        return (-1);
+
+                sin = (struct sockaddr_in *)sa;
+                memset(sin, 0, sizeof *sin);
+                sin->sin_len = sizeof(struct sockaddr_in);
+                sin->sin_family = PF_INET;
+                sin->sin_addr.s_addr = ina.s_addr;
+                return (0);
+
+        case PF_INET6:
+                if (inet_pton(PF_INET6, str, &in6a) != 1)
+                        return (-1);
+
+                sin6 = (struct sockaddr_in6 *)sa;
+                memset(sin6, 0, sizeof *sin6);
+                sin6->sin6_len = sizeof(struct sockaddr_in6);
+                sin6->sin6_family = PF_INET6;
+                sin6->sin6_addr = in6a;
+                return (0);
+
+        default:
+                break;
+        }
+
+        return (-1);
+}
diff --git a/src/regress/lib/libc/asr/bin/common.h b/src/regress/lib/libc/asr/bin/common.h
new file mode 100644
index 0000000000..87df4ae4a2
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/common.h
@@ -0,0 +1,136 @@
+/*      $OpenBSD: common.h,v 1.1.1.1 2012/07/13 17:49:53 eric Exp $     */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/types.h>
+#include <sys/socket.h>
+
+#include <arpa/nameser.h>
+
+#include <netinet/in.h>
+
+#include <netdb.h>
+
+
+#define unpack_rr               __unpack_rr
+#define unpack_header           __unpack_header
+#define packed_init             __packed_init
+#define unpack_query            __unpack_query
+#define sockaddr_from_str       __sockaddr_from_str
+#define print_addr              __print_addr
+
+extern int long_err;
+extern int gai_errno;
+extern int rrset_errno;
+
+const char *classtostr(uint16_t);
+const char *typetostr(uint16_t);
+const char *rcodetostr(uint16_t);
+
+uint16_t strtotype(const char*);
+uint16_t strtoclass(const char*);
+
+void    print_rrsetinfo(struct rrsetinfo *);
+void    print_addrinfo(struct addrinfo *);
+void    print_errors(void);
+void    print_hostent(struct hostent *);
+void    print_netent(struct netent *);
+
+int     sockaddr_from_str(struct sockaddr *, int, const char *);
+int     addr_from_str(char *, int *, int *, const char *);
+char*   gethostarg(char *);
+
+#define QR_MASK         (0x1 << 15)
+#define OPCODE_MASK     (0xf << 11)
+#define AA_MASK         (0x1 << 10)
+#define TC_MASK         (0x1 <<  9)
+#define RD_MASK         (0x1 <<  8)
+#define RA_MASK         (0x1 <<  7)
+#define Z_MASK          (0x7 <<  4)
+#define RCODE_MASK      (0xf)
+
+#define OPCODE(v)       ((v) & OPCODE_MASK)
+#define RCODE(v)        ((v) & RCODE_MASK)
+
+
+struct packed {
+        char            *data;
+        size_t           len;
+        size_t           offset;
+        const char      *err;
+};
+
+struct header {
+        uint16_t        id;
+        uint16_t        flags;
+        uint16_t        qdcount;
+        uint16_t        ancount;
+        uint16_t        nscount;
+        uint16_t        arcount;
+};
+
+struct query {
+        char            q_dname[MAXDNAME];
+        uint16_t        q_type;
+        uint16_t        q_class;
+};
+
+struct rr {
+        char            rr_dname[MAXDNAME];
+        uint16_t        rr_type;
+        uint16_t        rr_class;
+        uint32_t        rr_ttl;
+        union {
+                struct {
+                        char    cname[MAXDNAME];
+                } cname;
+                struct {
+                        uint16_t        preference;
+                        char            exchange[MAXDNAME];
+                } mx;
+                struct {
+                        char    nsname[MAXDNAME];
+                } ns;
+                struct {
+                        char    ptrname[MAXDNAME];
+                } ptr;
+                struct {
+                        char            mname[MAXDNAME];
+                        char            rname[MAXDNAME];
+                        uint32_t        serial;
+                        uint32_t        refresh;
+                        uint32_t        retry;
+                        uint32_t        expire;
+                        uint32_t        minimum;
+                } soa;
+                struct {
+                        struct in_addr  addr;
+                } in_a;
+                struct {
+                        struct in6_addr addr6;
+                } in_aaaa;
+                struct {
+                        uint16_t         rdlen;
+                        const void      *rdata;
+                } other;
+        } rr;
+};
+
+void    packed_init(struct packed*, char*, size_t);
+int     pack_header(struct packed*, const struct header*);
+int     pack_query(struct packed*, uint16_t, uint16_t, const char*);
+int     unpack_header(struct packed*, struct header*);
+int     unpack_query(struct packed*, struct query*);
+int     unpack_rr(struct packed*, struct rr*);
diff --git a/src/regress/lib/libc/asr/bin/getaddrinfo.c b/src/regress/lib/libc/asr/bin/getaddrinfo.c
new file mode 100644
index 0000000000..8c4abf361e
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/getaddrinfo.c
@@ -0,0 +1,131 @@
+/*      $OpenBSD: getaddrinfo.c,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $        */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/types.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+
+static void
+usage(void)
+{
+        extern const char * __progname;
+
+        fprintf(stderr, "usage: %s [-CHSPe] [-f family] [-p proto] "
+                "[-s servname]\n        [-t socktype] <host...>\n", __progname);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        struct addrinfo         *ai, *res, hints;
+        char                    *servname = NULL, *host;
+        int                      i, ch;
+
+        memset(&hints, 0, sizeof hints);
+
+        while((ch = getopt(argc, argv, "CFHPSef:p:s:t:")) !=  -1) {
+                switch(ch) {
+                case 'C':
+                        hints.ai_flags |= AI_CANONNAME;
+                        break;
+                case 'F':
+                        hints.ai_flags |= AI_FQDN;
+                        break;
+                case 'H':
+                        hints.ai_flags |= AI_NUMERICHOST;
+                        break;
+                case 'P':
+                        hints.ai_flags |= AI_PASSIVE;
+                        break;
+                case 'S':
+                        hints.ai_flags |= AI_NUMERICSERV;
+                        break;
+                case 'e':
+                        long_err += 1;
+                        break;
+                case 'f':
+                        if (!strcmp(optarg, "inet"))
+                                hints.ai_family = AF_INET;
+                        else if (!strcmp(optarg, "inet6"))
+                                hints.ai_family = AF_INET6;
+                        else
+                                usage();
+                        break;
+                case 'p':
+                        if (!strcmp(optarg, "udp"))
+                                hints.ai_protocol = IPPROTO_UDP;
+                        else if (!strcmp(optarg, "tcp"))
+                                hints.ai_protocol = IPPROTO_TCP;
+                        else
+                                usage();
+                        break;
+                case 's':
+                        servname = optarg;
+                        break;
+                case 't':
+                        if (!strcmp(optarg, "stream"))
+                                hints.ai_socktype = SOCK_STREAM;
+                        else if (!strcmp(optarg, "dgram"))
+                                hints.ai_socktype = SOCK_DGRAM;
+                        else if (!strcmp(optarg, "raw"))
+                                hints.ai_socktype = SOCK_RAW;
+                        else
+                                usage();
+                        break;
+                default:
+                        usage();
+                        /* NOTREACHED */
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        for(i = 0; i < argc; i++) {
+
+                if (i)
+                        printf("\n");
+                printf("===> \"%s\"\n", argv[i]);
+                host = gethostarg(argv[i]);
+
+                errno = 0;
+                h_errno = 0;
+                gai_errno = 0;
+                rrset_errno = 0;
+
+                gai_errno = getaddrinfo(host, servname, &hints, &ai);
+
+                print_errors();
+                if (gai_errno == 0) {
+                        for (res = ai; res; res = res->ai_next)
+                                print_addrinfo(res);
+                        freeaddrinfo(ai);
+                }
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/asr/bin/getaddrinfo/Makefile b/src/regress/lib/libc/asr/bin/getaddrinfo/Makefile
new file mode 100644
index 0000000000..ec2f104ec7
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/getaddrinfo/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $
+
+.PATH:  ${.CURDIR}/..
+
+PROG=   getaddrinfo
+SRCS+=  getaddrinfo.c
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/asr/bin/gethostnamadr.c b/src/regress/lib/libc/asr/bin/gethostnamadr.c
new file mode 100644
index 0000000000..b1b3e331a7
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/gethostnamadr.c
@@ -0,0 +1,113 @@
+/*      $OpenBSD: gethostnamadr.c,v 1.2 2012/07/29 19:51:36 eric Exp $  */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+
+static void
+usage(void)
+{
+        extern const char * __progname;
+
+        fprintf(stderr, "usage: %s [-46e] <host...>\n", __progname);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        int                      i, ch, aflag, family = AF_INET;
+        struct hostent          *h;
+        char                    *host;
+        char                     addr[16];
+        int                      addrlen;
+
+        aflag = 0;
+        while((ch = getopt(argc, argv, "46ae")) !=  -1) {
+                switch(ch) {
+                case '4':
+                        family = AF_INET;
+                        break;
+                case '6':
+                        family = AF_INET6;
+                        break;
+                case 'a':
+                        aflag = 1;
+                        break;
+                case 'e':
+                        long_err += 1;
+                        break;
+                default:
+                        usage();
+                        /* NOTREACHED */
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        for(i = 0; i < argc; i++) {
+
+                if (i)
+                        printf("\n");
+                printf("===> \"%s\"\n", argv[i]);
+                host = gethostarg(argv[i]);
+
+                if (aflag && addr_from_str(addr, &family, &addrlen, host) == -1)
+                        errx(1, "bad address");
+
+                errno = 0;
+                h_errno = 0;
+                gai_errno = 0;
+                rrset_errno = 0;
+
+                if (aflag == 0)
+                        h = gethostbyname2(host, family);
+                else
+                        h = gethostbyaddr(addr, addrlen, family);
+                if (h)
+                        print_hostent(h);
+                print_errors();
+        }
+
+        return (0);
+}
+
+int
+addr_from_str(char *addr, int *family, int *len, const char *src)
+{
+        if (inet_pton(AF_INET6, src, addr) == 1) {
+                *family = AF_INET6;
+                *len = 16;
+                return (0);
+        }
+        if (inet_pton(AF_INET, src, addr) == 1) {
+                *family = AF_INET;
+                *len = 4;
+                return (0);
+        }
+        return (-1);
+}
diff --git a/src/regress/lib/libc/asr/bin/gethostnamadr/Makefile b/src/regress/lib/libc/asr/bin/gethostnamadr/Makefile
new file mode 100644
index 0000000000..84906ffbbd
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/gethostnamadr/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $
+
+.PATH:  ${.CURDIR}/..
+
+PROG=   gethostnamadr
+SRCS+=  gethostnamadr.c
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/asr/bin/getnameinfo.c b/src/regress/lib/libc/asr/bin/getnameinfo.c
new file mode 100644
index 0000000000..8702937a47
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/getnameinfo.c
@@ -0,0 +1,112 @@
+/*      $OpenBSD: getnameinfo.c,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $        */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+
+static void
+usage(void)
+{
+        extern const char * __progname;
+
+        fprintf(stderr, "usage: %s [-DFHNSe] [-p portno] <addr...>\n", __progname);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        char                     serv[1024];
+        char                     host[1024];
+        const char               *e;
+        int                      i, ch, flags = 0, port = 0;
+        struct sockaddr_storage  ss;
+        struct sockaddr         *sa;
+
+        sa = (struct sockaddr*)&ss;
+
+        while((ch = getopt(argc, argv, "DFHNSaep:")) !=  -1) {
+                switch(ch) {
+                case 'D':
+                        flags |= NI_DGRAM;
+                        break;
+                case 'F':
+                        flags |= NI_NOFQDN;
+                        break;
+                case 'H':
+                        flags |= NI_NUMERICHOST;
+                        break;
+                case 'N':
+                        flags |= NI_NAMEREQD;
+                        break;
+                case 'S':
+                        flags |= NI_NUMERICSERV;
+                        break;
+                case 'e':
+                        long_err += 1;
+                        break;
+                case 'p':
+                        port = strtonum(optarg, 0, 65535, &e);
+                        if (e)
+                                usage();
+                        break;
+                default:
+                        usage();
+                        /* NOTREACHED */
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        for(i = 0; i < argc; i++) {
+
+                if (i)
+                        printf("\n");
+                printf("===> \"%s\"\n", argv[i]);
+
+                if (sockaddr_from_str(sa, AF_UNSPEC, argv[i]) == -1) {
+                        printf("   => invalid address\n");
+                        continue;
+                }
+
+                if (sa->sa_family == PF_INET)
+                        ((struct sockaddr_in *)sa)->sin_port = htons(port);
+                else if (sa->sa_family == PF_INET6)
+                        ((struct sockaddr_in6 *)sa)->sin6_port = htons(port);
+
+                errno = 0;
+                h_errno = 0;
+                gai_errno = 0;
+                rrset_errno = 0;
+
+                gai_errno = getnameinfo(sa, sa->sa_len, host, sizeof host, serv,
+                    sizeof serv, flags);
+
+                if (gai_errno == 0)
+                        printf("   %s:%s\n", host, serv);
+                print_errors();
+
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/asr/bin/getnameinfo/Makefile b/src/regress/lib/libc/asr/bin/getnameinfo/Makefile
new file mode 100644
index 0000000000..4927ee9486
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/getnameinfo/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $
+
+.PATH:  ${.CURDIR}/..
+
+PROG=   getnameinfo
+SRCS+=  getnameinfo.c
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/asr/bin/getnetnamadr.c b/src/regress/lib/libc/asr/bin/getnetnamadr.c
new file mode 100644
index 0000000000..4b7414264b
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/getnetnamadr.c
@@ -0,0 +1,85 @@
+/*      $OpenBSD: getnetnamadr.c,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $       */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+
+static void
+usage(void)
+{
+        extern const char * __progname;
+
+        fprintf(stderr, "usage: %s [-aen] [host...]\n", __progname);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        int                      i, ch, nflag = 0;
+        struct netent           *n;
+        char                    *host;
+
+        while((ch = getopt(argc, argv, "en")) !=  -1) {
+                switch(ch) {
+                case 'e':
+                        long_err += 1;
+                        break;
+                case 'n':
+                        nflag = 1;
+                        break;
+                default:
+                        usage();
+                        /* NOTREACHED */
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        for(i = 0; i < argc; i++) {
+
+                if (i)
+                        printf("\n");
+                printf("===> \"%s\"\n", argv[i]);
+                host = gethostarg(argv[i]);
+
+                errno = 0;
+                h_errno = 0;
+                gai_errno = 0;
+                rrset_errno = 0;
+
+                if (nflag)
+                        n = getnetbyname(host);
+                else
+                        n = getnetbyaddr(inet_network(host), AF_INET);
+                if (n)
+                        print_netent(n);
+                print_errors();
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/asr/bin/getnetnamadr/Makefile b/src/regress/lib/libc/asr/bin/getnetnamadr/Makefile
new file mode 100644
index 0000000000..521bf8eb7e
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/getnetnamadr/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $
+
+.PATH:  ${.CURDIR}/..
+
+PROG=   getnetnamadr
+SRCS+=  getnetnamadr.c
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/asr/bin/getrrsetbyname.c b/src/regress/lib/libc/asr/bin/getrrsetbyname.c
new file mode 100644
index 0000000000..4a5aa57209
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/getrrsetbyname.c
@@ -0,0 +1,88 @@
+/*      $OpenBSD: getrrsetbyname.c,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $     */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/types.h>
+
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+
+static void
+usage(void)
+{
+        extern const char * __progname;
+
+        fprintf(stderr, "usage: %s [-e] [-t type] [host...]\n",
+            __progname);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        int                     ch, i;
+        uint16_t                type = T_A;
+        char                    *host;
+        struct rrsetinfo        *rrset;
+
+        while((ch = getopt(argc, argv, "et:")) !=  -1) {
+                switch(ch) {
+                case 'e':
+                        long_err += 1;
+                        break;
+                case 't':
+                        if ((type = strtotype(optarg)) == 0)
+                                usage();
+                        break;
+                default:
+                        usage();
+                        /* NOTREACHED */
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        for (i = 0; i < argc; i++) {
+
+                if (i)
+                        printf("\n");
+                printf("===> \"%s\"\n", argv[i]);
+                host = gethostarg(argv[i]);
+                
+                errno = 0;
+                h_errno = 0;
+                gai_errno = 0;
+                rrset_errno = 0;
+                
+                rrset_errno = getrrsetbyname(host, C_IN, type, 0, &rrset);
+
+                if (rrset_errno == 0)
+                        print_rrsetinfo(rrset);
+                print_errors();
+        }
+        
+        return (0);
+}
diff --git a/src/regress/lib/libc/asr/bin/getrrsetbyname/Makefile b/src/regress/lib/libc/asr/bin/getrrsetbyname/Makefile
new file mode 100644
index 0000000000..131403bea1
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/getrrsetbyname/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $
+
+.PATH:  ${.CURDIR}/..
+
+PROG=   getrrsetbyname
+SRCS+=  getrrsetbyname.c
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/asr/bin/res_mkquery.c b/src/regress/lib/libc/asr/bin/res_mkquery.c
new file mode 100644
index 0000000000..a52023c5c0
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/res_mkquery.c
@@ -0,0 +1,319 @@
+/*      $OpenBSD: res_mkquery.c,v 1.1.1.1 2012/07/13 17:49:53 eric Exp $        */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/types.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <arpa/inet.h>
+
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+
+/* in asr.c but we don't want them exposed right now */
+static void dump_packet(const void *, size_t);
+
+static char *print_query(struct query *, char *, size_t);
+static char *print_rr(struct rr *, char *, size_t);
+static char *print_host(const struct sockaddr *, char *, size_t);
+static char* print_dname(const char *, char *, size_t);
+
+
+static void
+usage(void)
+{
+        extern const char * __progname;
+
+        fprintf(stderr, "usage: %s [-deq] [-t type] [host...]\n",
+            __progname);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        int                      ch, i, r;
+        uint16_t                 type = T_A;
+        char                     buf[1024], *host;
+
+        while((ch = getopt(argc, argv, "et:")) !=  -1) {
+                switch(ch) {
+                case 'e':
+                        long_err += 1;
+                        break;
+                case 't':
+                        if ((type = strtotype(optarg)) == 0)
+                                usage();
+                        break;
+                default:
+                        usage();
+                        /* NOTREACHED */
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        for (i = 0; i < argc; i++) {
+
+                if (i)
+                        printf("\n");
+
+                printf("===> \"%s\"\n", argv[i]);
+                host = gethostarg(argv[i]);
+
+                errno = 0;
+                h_errno = 0;
+                gai_errno = 0;
+                rrset_errno = 0;
+
+                r = res_mkquery(QUERY, host, C_IN, type, NULL, 0, NULL, buf, sizeof(buf));
+                if (r != -1) {
+                        dump_packet(buf, r);
+                        printf(";; MSG SIZE %i\n", r);
+                }
+                print_errors();
+        }
+
+        return (0);
+}
+
+#define OPCODE_SHIFT    11
+#define Z_SHIFT         4
+
+static char*
+print_header(struct header *h, char *buf, size_t max)
+{
+        snprintf(buf, max,
+        "id:0x.... %s op:%i %s %s %s %s z:%i r:%s qd:%i an:%i ns:%i ar:%i",
+            (h->flags & QR_MASK) ? "QR":"  ",
+            (int)(OPCODE(h->flags) >> OPCODE_SHIFT),
+            (h->flags & AA_MASK) ? "AA":"  ",
+            (h->flags & TC_MASK) ? "TC":"  ",
+            (h->flags & RD_MASK) ? "RD":"  ",
+            (h->flags & RA_MASK) ? "RA":"  ",  
+            ((h->flags & Z_MASK) >> Z_SHIFT),
+            rcodetostr(RCODE(h->flags)),
+            h->qdcount, h->ancount, h->nscount, h->arcount);
+
+        return buf;
+}
+
+static void
+dump_packet(const void *data, size_t len)
+{
+        char            buf[1024];
+        struct packed   p;
+        struct header   h;
+        struct query    q;
+        struct rr       rr;
+        int             i, an, ns, ar, n;
+
+        packed_init(&p, (char *)data, len);
+
+        if (unpack_header(&p, &h) == -1) {
+                printf(";; BAD PACKET: %s\n", p.err);
+                return;
+        }
+
+        printf(";; HEADER %s\n", print_header(&h, buf, sizeof buf));
+
+        if (h.qdcount)
+                printf(";; QUERY SECTION:\n");
+        for (i = 0; i < h.qdcount; i++) {
+                if (unpack_query(&p, &q) == -1)
+                        goto error;
+                printf("%s\n", print_query(&q, buf, sizeof buf));
+        }
+
+        an = 0;
+        ns = an + h.ancount;
+        ar = ns + h.nscount;
+        n = ar + h.arcount;
+
+        for (i = 0; i < n; i++) {
+                if (i == an)
+                        printf("\n;; ANSWER SECTION:\n");
+                if (i == ns)
+                        printf("\n;; AUTHORITY SECTION:\n");
+                if (i == ar)
+                        printf("\n;; ADDITIONAL SECTION:\n");
+
+                if (unpack_rr(&p, &rr) == -1)
+                        goto error;
+                printf("%s\n", print_rr(&rr, buf, sizeof buf));
+        }
+
+        if (p.offset != len)
+                printf(";; REMAINING GARBAGE %zu\n", len - p.offset);
+
+    error:
+        if (p.err)
+                printf(";; ERROR AT OFFSET %zu/%zu: %s\n", p.offset, p.len,
+                    p.err);
+}
+
+static const char *
+inet6_ntoa(struct in6_addr a)
+{
+        static char buf[256];
+        struct sockaddr_in6     si;
+
+        si.sin6_len = sizeof(si);
+        si.sin6_family = PF_INET6;
+        si.sin6_addr = a;
+
+        return print_host((struct sockaddr*)&si, buf, sizeof buf);
+}
+
+static char*
+print_rr(struct rr *rr, char *buf, size_t max)
+{
+        char    *res;
+        char     tmp[256];
+        char     tmp2[256];
+        int      r;
+
+        res = buf;
+
+        r = snprintf(buf, max, "%s %u %s %s ",
+            print_dname(rr->rr_dname, tmp, sizeof tmp),
+            rr->rr_ttl,
+            classtostr(rr->rr_class),
+            typetostr(rr->rr_type));
+        if (r == -1) {
+                buf[0] = '\0';
+                return buf;
+        }
+
+        if ((size_t)r >= max)
+                return buf;
+
+        max -= r;
+        buf += r;
+
+        switch(rr->rr_type) {
+        case T_CNAME:
+                print_dname(rr->rr.cname.cname, buf, max);
+                break;
+        case T_MX:
+                snprintf(buf, max, "%"PRIu32" %s",
+                    rr->rr.mx.preference,
+                    print_dname(rr->rr.mx.exchange, tmp, sizeof tmp));
+                break;
+        case T_NS:
+                print_dname(rr->rr.ns.nsname, buf, max);
+                break;
+        case T_PTR:
+                print_dname(rr->rr.ptr.ptrname, buf, max);
+                break;
+        case T_SOA:
+                snprintf(buf, max,
+                    "%s %s %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32,
+                    print_dname(rr->rr.soa.rname, tmp, sizeof tmp),
+                    print_dname(rr->rr.soa.mname, tmp2, sizeof tmp2),
+                    rr->rr.soa.serial,
+                    rr->rr.soa.refresh,
+                    rr->rr.soa.retry,
+                    rr->rr.soa.expire,
+                    rr->rr.soa.minimum);
+                break;
+        case T_A:
+                if (rr->rr_class != C_IN)
+                        goto other;
+                snprintf(buf, max, "%s", inet_ntoa(rr->rr.in_a.addr));
+                break;
+        case T_AAAA:
+                if (rr->rr_class != C_IN)
+                        goto other;
+                snprintf(buf, max, "%s", inet6_ntoa(rr->rr.in_aaaa.addr6));
+                break;
+        default:
+        other:
+                snprintf(buf, max, "(rdlen=%"PRIu16 ")", rr->rr.other.rdlen);
+                break;
+        }
+
+        return (res);
+}
+
+static char*
+print_query(struct query *q, char *buf, size_t max)
+{
+        char b[256];
+
+        snprintf(buf, max, "%s  %s %s",
+            print_dname(q->q_dname, b, sizeof b),
+            classtostr(q->q_class), typetostr(q->q_type));
+
+        return (buf);
+}
+
+
+static char *
+print_host(const struct sockaddr *sa, char *buf, size_t len)
+{
+        switch (sa->sa_family) {
+        case AF_INET:
+                inet_ntop(AF_INET, &((struct sockaddr_in*)sa)->sin_addr, buf, len);
+                break;
+        case AF_INET6:
+                inet_ntop(AF_INET6, &((struct sockaddr_in6*)sa)->sin6_addr, buf, len);
+                break;
+        default:
+                buf[0] = '\0';
+        }
+        return (buf);
+}
+
+static char*
+print_dname(const char *_dname, char *buf, size_t max)
+{
+        const unsigned char *dname = _dname;
+        char    *res;
+        size_t   left, n, count;
+
+        if (_dname[0] == 0) {
+                strlcpy(buf, ".", max);
+                return buf;
+        }
+
+        res = buf;
+        left = max - 1;
+        for (n = 0; dname[0] && left; n += dname[0]) {
+                count = (dname[0] < (left - 1)) ? dname[0] : (left - 1);
+                memmove(buf, dname + 1, count);
+                dname += dname[0] + 1;
+                left -= count;
+                buf += count;
+                if (left) {
+                        left -= 1;
+                        *buf++ = '.';
+                }
+        }
+        buf[0] = 0;
+
+        return (res);
+}
diff --git a/src/regress/lib/libc/asr/bin/res_mkquery/Makefile b/src/regress/lib/libc/asr/bin/res_mkquery/Makefile
new file mode 100644
index 0000000000..770fa9f633
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/res_mkquery/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $
+
+.PATH:  ${.CURDIR}/..
+
+PROG=   res_mkquery${BINEXT}
+SRCS+=  res_mkquery.c
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/asr/bin/res_query.c b/src/regress/lib/libc/asr/bin/res_query.c
new file mode 100644
index 0000000000..fd96f1de22
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/res_query.c
@@ -0,0 +1,354 @@
+/*      $OpenBSD: res_query.c,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $  */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/types.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <arpa/inet.h>
+
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+
+/* in asr.c but we don't want them exposed right now */
+static void dump_packet(const void *, size_t);
+
+static char *print_query(struct query *, char *, size_t);
+static char *print_rr(struct rr *, char *, size_t);
+static char *print_host(const struct sockaddr *, char *, size_t);
+static char* print_dname(const char *, char *, size_t);
+
+
+static int
+msec(struct timeval start, struct timeval end)
+{
+        return (int)((end.tv_sec - start.tv_sec) * 1000
+            + (end.tv_usec - start.tv_usec) / 1000);
+}
+
+static void
+usage(void)
+{
+        extern const char * __progname;
+
+        fprintf(stderr, "usage: %s [-deq] [-t type] [host...]\n",
+            __progname);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        struct timeval           start, end;
+        time_t                   when;
+        int                      ch, i, qflag, dflag, r;
+        uint16_t                 type = T_A;
+        char                     buf[1024], *host;
+
+        dflag = 0;
+        qflag = 0;
+
+        while((ch = getopt(argc, argv, "deqt:")) !=  -1) {
+                switch(ch) {
+                case 'd':
+                        dflag = 1;
+                        break;
+                case 'e':
+                        long_err += 1;
+                        break;
+                case 'q':
+                        qflag = 1;
+                        break;
+                case 't':
+                        if ((type = strtotype(optarg)) == 0)
+                                usage();
+                        break;
+                default:
+                        usage();
+                        /* NOTREACHED */
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        for (i = 0; i < argc; i++) {
+
+                if (i)
+                        printf("\n");
+
+                printf("===> \"%s\"\n", argv[i]);
+                host = gethostarg(argv[i]);
+
+                errno = 0;
+                h_errno = 0;
+                gai_errno = 0;
+                rrset_errno = 0;
+
+                if (gettimeofday(&start, NULL) != 0)
+                        err(1, "gettimeofday");
+
+                if (qflag)
+                        r = res_query(host, C_IN, type, buf, sizeof(buf));
+                else
+                        r = res_search(host, C_IN, type, buf, sizeof(buf));
+
+                if (gettimeofday(&end, NULL) != 0)
+                        err(1, "gettimeofday");
+
+                if (r != -1) {
+                        dump_packet(buf, r);
+                        printf("\n");
+                        if (dflag) {
+                                printf(";; Query time: %d msec\n",
+                                    msec(start, end));
+                                when = time(NULL);
+                                printf(";; WHEN: %s", ctime(&when));
+                        }
+                        printf(";; MSG SIZE  rcvd: %i\n", r);
+                }
+                print_errors();
+        }
+
+        return (0);
+}
+
+#define OPCODE_SHIFT    11
+#define Z_SHIFT         4
+
+static char*
+print_header(struct header *h, char *buf, size_t max)
+{
+        snprintf(buf, max,
+        "id:0x.... %s op:%i %s %s %s %s z:%i r:%s qd:%i an:%i ns:%i ar:%i",
+            (h->flags & QR_MASK) ? "QR":"  ",
+            (int)(OPCODE(h->flags) >> OPCODE_SHIFT),
+            (h->flags & AA_MASK) ? "AA":"  ",
+            (h->flags & TC_MASK) ? "TC":"  ",
+            (h->flags & RD_MASK) ? "RD":"  ",
+            (h->flags & RA_MASK) ? "RA":"  ",  
+            ((h->flags & Z_MASK) >> Z_SHIFT),
+            rcodetostr(RCODE(h->flags)),
+            h->qdcount, h->ancount, h->nscount, h->arcount);
+
+        return buf;
+}
+
+static void
+dump_packet(const void *data, size_t len)
+{
+        char            buf[1024];
+        struct packed   p;
+        struct header   h;
+        struct query    q;
+        struct rr       rr;
+        int             i, an, ns, ar, n;
+
+        packed_init(&p, (char *)data, len);
+
+        if (unpack_header(&p, &h) == -1) {
+                printf(";; BAD PACKET: %s\n", p.err);
+                return;
+        }
+
+        printf(";; HEADER %s\n", print_header(&h, buf, sizeof buf));
+
+        if (h.qdcount)
+                printf(";; QUERY SECTION:\n");
+        for (i = 0; i < h.qdcount; i++) {
+                if (unpack_query(&p, &q) == -1)
+                        goto error;
+                printf("%s\n", print_query(&q, buf, sizeof buf));
+        }
+
+        an = 0;
+        ns = an + h.ancount;
+        ar = ns + h.nscount;
+        n = ar + h.arcount;
+
+        for (i = 0; i < n; i++) {
+                if (i == an)
+                        printf("\n;; ANSWER SECTION:\n");
+                if (i == ns)
+                        printf("\n;; AUTHORITY SECTION:\n");
+                if (i == ar)
+                        printf("\n;; ADDITIONAL SECTION:\n");
+
+                if (unpack_rr(&p, &rr) == -1)
+                        goto error;
+                printf("%s\n", print_rr(&rr, buf, sizeof buf));
+        }
+
+        if (p.offset != len)
+                printf(";; REMAINING GARBAGE %zu\n", len - p.offset);
+
+    error:
+        if (p.err)
+                printf(";; ERROR AT OFFSET %zu/%zu: %s\n", p.offset, p.len,
+                    p.err);
+}
+
+static const char *
+inet6_ntoa(struct in6_addr a)
+{
+        static char buf[256];
+        struct sockaddr_in6     si;
+
+        si.sin6_len = sizeof(si);
+        si.sin6_family = PF_INET6;
+        si.sin6_addr = a;
+
+        return print_host((struct sockaddr*)&si, buf, sizeof buf);
+}
+
+static char*
+print_rr(struct rr *rr, char *buf, size_t max)
+{
+        char    *res;
+        char     tmp[256];
+        char     tmp2[256];
+        int      r;
+
+        res = buf;
+
+        r = snprintf(buf, max, "%s %u %s %s ",
+            print_dname(rr->rr_dname, tmp, sizeof tmp),
+            rr->rr_ttl,
+            classtostr(rr->rr_class),
+            typetostr(rr->rr_type));
+        if (r == -1) {
+                buf[0] = '\0';
+                return buf;
+        }
+
+        if ((size_t)r >= max)
+                return buf;
+
+        max -= r;
+        buf += r;
+
+        switch(rr->rr_type) {
+        case T_CNAME:
+                print_dname(rr->rr.cname.cname, buf, max);
+                break;
+        case T_MX:
+                snprintf(buf, max, "%"PRIu32" %s",
+                    rr->rr.mx.preference,
+                    print_dname(rr->rr.mx.exchange, tmp, sizeof tmp));
+                break;
+        case T_NS:
+                print_dname(rr->rr.ns.nsname, buf, max);
+                break;
+        case T_PTR:
+                print_dname(rr->rr.ptr.ptrname, buf, max);
+                break;
+        case T_SOA:
+                snprintf(buf, max,
+                    "%s %s %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32,
+                    print_dname(rr->rr.soa.rname, tmp, sizeof tmp),
+                    print_dname(rr->rr.soa.mname, tmp2, sizeof tmp2),
+                    rr->rr.soa.serial,
+                    rr->rr.soa.refresh,
+                    rr->rr.soa.retry,
+                    rr->rr.soa.expire,
+                    rr->rr.soa.minimum);
+                break;
+        case T_A:
+                if (rr->rr_class != C_IN)
+                        goto other;
+                snprintf(buf, max, "%s", inet_ntoa(rr->rr.in_a.addr));
+                break;
+        case T_AAAA:
+                if (rr->rr_class != C_IN)
+                        goto other;
+                snprintf(buf, max, "%s", inet6_ntoa(rr->rr.in_aaaa.addr6));
+                break;
+        default:
+        other:
+                snprintf(buf, max, "(rdlen=%"PRIu16 ")", rr->rr.other.rdlen);
+                break;
+        }
+
+        return (res);
+}
+
+static char*
+print_query(struct query *q, char *buf, size_t max)
+{
+        char b[256];
+
+        snprintf(buf, max, "%s  %s %s",
+            print_dname(q->q_dname, b, sizeof b),
+            classtostr(q->q_class), typetostr(q->q_type));
+
+        return (buf);
+}
+
+
+static char *
+print_host(const struct sockaddr *sa, char *buf, size_t len)
+{
+        switch (sa->sa_family) {
+        case AF_INET:
+                inet_ntop(AF_INET, &((struct sockaddr_in*)sa)->sin_addr, buf, len);
+                break;
+        case AF_INET6:
+                inet_ntop(AF_INET6, &((struct sockaddr_in6*)sa)->sin6_addr, buf, len);
+                break;
+        default:
+                buf[0] = '\0';
+        }
+        return (buf);
+}
+
+static char*
+print_dname(const char *_dname, char *buf, size_t max)
+{
+        const unsigned char *dname = _dname;
+        char    *res;
+        size_t   left, n, count;
+
+        if (_dname[0] == 0) {
+                strlcpy(buf, ".", max);
+                return buf;
+        }
+
+        res = buf;
+        left = max - 1;
+        for (n = 0; dname[0] && left; n += dname[0]) {
+                count = (dname[0] < (left - 1)) ? dname[0] : (left - 1);
+                memmove(buf, dname + 1, count);
+                dname += dname[0] + 1;
+                left -= count;
+                buf += count;
+                if (left) {
+                        left -= 1;
+                        *buf++ = '.';
+                }
+        }
+        buf[0] = 0;
+
+        return (res);
+}
diff --git a/src/regress/lib/libc/asr/bin/res_query/Makefile b/src/regress/lib/libc/asr/bin/res_query/Makefile
new file mode 100644
index 0000000000..75380ee079
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/res_query/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $
+
+.PATH:  ${.CURDIR}/..
+
+PROG=   res_query${BINEXT}
+SRCS+=  res_query.c
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/asr/bin/threads.c b/src/regress/lib/libc/asr/bin/threads.c
new file mode 100644
index 0000000000..f296f1d6f7
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/threads.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: threads.c,v 1.1.1.1 2012/07/13 17:49:53 eric Exp $    */
+/*
+ * Copyright (c) 2012 Eric Faurot <eric@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 <sys/time.h>
+#include <sys/resource.h>
+
+#include <assert.h>
+#include <err.h>
+#include <getopt.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <netdb.h>
+
+#define MAX_THREADS     50
+
+int       ac;
+char    **av;
+int       loop;
+int       nthreads;
+
+int long_err;
+int gai_errno;
+int rrset_errno;
+
+void async_resolver_done(void *);
+
+void stats(void)
+{
+        struct rusage   ru;
+
+        getrusage(RUSAGE_SELF, &ru);
+        printf("%li\n", ru.ru_maxrss);
+}
+
+void*
+task(void *arg)
+{
+        int              id, i, j, c;
+        struct addrinfo *ai, *n;
+
+        id = *((int*) arg);
+
+        n = NULL; c =0;
+
+        for(j = 0; j < loop; j++)
+                for(i = 0; i < ac; i++) {
+                        if (getaddrinfo(av[i], NULL, NULL, &ai) == 0) {
+/*
+                                for (c = 0, n = ai; n; c++, n = n->ai_next);
+                                printf("%i:%s: ok: %i\n", id, av[i], c);
+*/
+                                freeaddrinfo(ai);
+                        } else {
+/*
+                                printf("%i:%s: fail\n", id, av[i]);
+*/
+                        }
+                }
+        return (NULL);
+}
+
+void
+usage(void)
+{
+        extern const char *__progname;
+        fprintf(stderr, "usage: %s [-L loop] [-l loop] [-t threads] <host> ...\n",
+                __progname);
+}
+
+int
+main(int argc, char **argv)
+{
+        pthread_t       th[MAX_THREADS];
+        int             th_args[MAX_THREADS], r, i, ch;
+        int             n, LOOP;
+
+        nthreads = 1;
+        loop = 1;
+        LOOP = 1;
+
+        while ((ch = getopt(argc, argv, "L:l:t:")) != -1) {
+                switch (ch) {
+                case 'L':
+                        LOOP = atoi(optarg);
+                        break;
+                case 'l':
+                        loop = atoi(optarg);
+                        break;
+                case 't':
+                        nthreads = atoi(optarg);
+                        if (nthreads > MAX_THREADS)
+                                nthreads = MAX_THREADS;
+                        break;
+                default:
+                        usage();
+                        /* NOTREACHED */
+                }
+        }
+
+        argc -= optind;
+        argv += optind;
+
+        ac = argc;
+        av = argv;
+
+        printf("%i %i %i\n", LOOP, nthreads, loop);
+        for (n = 0; n < LOOP; n ++) {
+                for (i = 0; i < nthreads; i++) {
+                        th_args[i] = i;
+                        r = pthread_create(&th[i], NULL, task, (void *) &th_args[i]);
+                        if (r == -1)
+                                errx(1, "pthread_create");
+                }
+                for (i = 0; i < nthreads; i++)
+                        pthread_join(th[i], NULL);
+
+                if (nthreads == 0)
+                        task(&n);
+
+                stats();
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/asr/bin/threads/Makefile b/src/regress/lib/libc/asr/bin/threads/Makefile
new file mode 100644
index 0000000000..3252511cd1
--- /dev/null
+++ b/src/regress/lib/libc/asr/bin/threads/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.1.1.1 2012/07/13 17:49:54 eric Exp $
+
+.PATH:  ${.CURDIR}/..
+
+PROG=   threads
+SRCS+=  threads.c
+
+LDADD=  -lpthread
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/asr/regress.sh b/src/regress/lib/libc/asr/regress.sh
new file mode 100644
index 0000000000..513732c068
--- /dev/null
+++ b/src/regress/lib/libc/asr/regress.sh
@@ -0,0 +1,104 @@
+#       $OpenBSD: regress.sh,v 1.3 2012/09/05 21:23:36 eric Exp $
+
+. regress.subr
+
+EFLAG=
+
+test_res_mkquery()
+{
+        for i in $@; do
+                regress res_mkquery $i
+        done
+}
+
+test_res_query()
+{
+        for i in $@; do
+                regress res_query $i
+                regress res_query -q $i
+        done
+}
+
+test_getrrsetbyname()
+{
+        for i in $@; do
+                regress getrrsetbyname $i
+                regress getrrsetbyname -t MX $i
+                regress getrrsetbyname -t AAAA $i
+        done
+}
+
+test_gethostbyname()
+{
+        for i in $@; do
+                regress gethostnamadr $i
+                regress gethostnamadr -4 $i
+                regress gethostnamadr -6 $i
+        done
+}
+
+test_gethostbyaddr()
+{
+        for i in $@; do
+                regress gethostnamadr -a $i
+        done
+}
+
+test_getaddrinfo()
+{
+        for i in $@; do
+                regress getaddrinfo $i
+                regress getaddrinfo -C $i
+                regress getaddrinfo -F $i
+                regress getaddrinfo -CF $i
+                regress getaddrinfo -P $i
+                regress getaddrinfo -PF $i
+                regress getaddrinfo -PC $i
+                regress getaddrinfo -H $i
+                regress getaddrinfo -p tcp $i
+                regress getaddrinfo -p udp $i
+                regress getaddrinfo -s www $i
+                regress getaddrinfo -s bad $i
+                regress getaddrinfo -S -s 8081 $i
+                regress getaddrinfo -S -s bad $i
+                regress getaddrinfo -P -s syslog $i
+                regress getaddrinfo -P -s syslog -p tcp $i
+                regress getaddrinfo -P -s syslog -p udp $i
+        done
+}
+
+test_getnameinfo()
+{
+        for i in $@; do
+                regress getnameinfo $i
+                regress getnameinfo -D $i
+                regress getnameinfo -F $i
+                regress getnameinfo -H $i
+                regress getnameinfo -N $i
+                regress getnameinfo -S $i
+                regress getnameinfo -p 80 $i
+                regress getnameinfo -p 514 $i
+                regress getnameinfo -p 514 -D $i
+                regress getnameinfo -p 5566 $i
+        done
+}
+
+WEIRD="EMPTY . .. ..."
+BASIC="localhost $(hostname -s) $(hostname)"
+EXTRA="undeadly.org www.openbsd.org cvs.openbsd.org"
+
+ADDRS="0.0.0.0 :: 127.0.0.1 ::1 212.227.193.194"
+
+for e in file bind local; do
+        regress_setenv $e
+
+        test_res_mkquery $WEIRD $BASIC
+        test_res_query $WEIRD $BASIC $EXTRA
+        test_getrrsetbyname $WEIRD $BASIC $EXTRA
+        test_gethostbyname $WEIRD $BASIC $EXTRA
+        test_gethostbyaddr $ADDRS
+        test_getaddrinfo NULL $WEIRD $BASIC $EXTRA
+        test_getnameinfo $ADDRS
+done
+
+regress_digest
diff --git a/src/regress/lib/libc/asr/regress.subr b/src/regress/lib/libc/asr/regress.subr
new file mode 100644
index 0000000000..dafb7ddf75
--- /dev/null
+++ b/src/regress/lib/libc/asr/regress.subr
@@ -0,0 +1,114 @@
+#!/bin/sh
+#       $OpenBSD: regress.subr,v 1.1.1.1 2012/07/13 17:49:53 eric Exp $
+
+TOTAL=0
+FAIL=0
+OK=0
+
+EXT0=.std
+EXT1=.asr
+EFLAG=-ee
+
+set -e
+
+fail()
+{
+        echo "*** ERROR: $@"
+        exit 1
+}
+
+regress()
+{
+        local out;
+        local _cmd=$1;
+        local _bin0=/bin/$_cmd$EXT0
+        local _bin1=/bin/$_cmd$EXT1
+        shift;
+
+        TOTAL=$((TOTAL+1))
+
+        # XXX with user "bin"
+        test -x $_RUNDIR$_bin0 || fail $_RUNDIR$_bin0 not executable
+        test -x $_RUNDIR$_bin1 || fail $_RUNDIR$_bin1 not executable
+
+        out=/tmp/asr_regress
+
+        echo -n $_cmd $EFLAG $@ "."
+
+        set +e
+        chroot -u bin "$_RUNDIR" $_bin0 $EFLAG $@ > $out.0
+        echo -n .
+        chroot -u bin "$_RUNDIR" $_bin1 $EFLAG $@ > $out.1
+        echo -n ". "
+
+        diff -u $out.0 $out.1 > $out.diff
+        set -e
+        if test -s $out.diff; then
+                FAIL=$((FAIL+1))
+                echo fail
+                echo "*** FAIL (env=$REGRESSENV)" $_cmd $EFLAG $@ >> $REG
+                tail -n +3 $out.diff >> $REG
+                echo >> $REG
+        else
+                OK=$((OK+1))
+                echo ok
+                echo "OK (env=$REGRESSENV)" $_cmd $EFLAG $@ >> $OUT
+                cat $out.0 >> $OUT
+                echo >> $OUT
+        fi
+        rm $out.diff $out.0 $out.1
+}
+
+regress_setenv()
+{
+        local _name="$1"
+
+        echo "===> using env $_name"
+
+        cp /etc/hosts $_RUNDIR/etc/
+        cp /etc/resolv.conf $_RUNDIR/etc/
+        cp /etc/protocols $_RUNDIR/etc/
+        cp /etc/networks $_RUNDIR/etc/
+
+        case $_name in
+        empty)
+                rm -f $_RUNDIR/etc/*
+                ;;
+        local)
+                ;;
+        file)
+                grep -v lookup /etc/resolv.conf > $_RUNDIR/etc/resolv.conf
+                echo "lookup file" >> $_RUNDIR/etc/resolv.conf
+                ;;
+        bind)
+                grep -v lookup /etc/resolv.conf > $_RUNDIR/etc/resolv.conf
+                echo "lookup bind" >> $_RUNDIR/etc/resolv.conf
+                ;;
+        *)
+                fail unknown env $_name
+                ;;
+        esac
+        REGRESSENV=$_name
+}
+
+regress_digest()
+{
+        echo
+        cat $REG
+        echo "===>" run=$TOTAL fail=$FAIL
+}
+
+
+# needed for chroot
+test "$(id -u)" -ne 0 && fail need root privileges to run this script
+
+# we really really want to avoid erasing /etc later
+test "$RUNDIR" || fail RUNDIR is not set
+_RUNDIR=$(readlink -fn ${RUNDIR})
+test "$_RUNDIR" == / && fail RUNDIR is root dir: $RUNDIR
+
+OUT=$_RUNDIR/output.log
+REG=$_RUNDIR/regress.log
+
+echo -n > $REG
+echo -n > $OUT
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
new file mode 100644
index 0000000000..7d2882594d
--- /dev/null
+++ b/src/regress/lib/libc/db/Makefile
@@ -0,0 +1,22 @@
+#       $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
+CLEANFILES+= t1 t2 t3 log
+
+DBTARGETS=1 2 3 4 5 6 7 8 9 10 11 12 13 20
+
+.for DT in ${DBTARGETS}
+db-${DT}: ${PROG}
+        sh ${.CURDIR}/run.test ${DT}
+REGRESS_TARGETS+=db-${DT}
+.PHONY: db-${DT}
+.endfor
+
+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
new file mode 100644
index 0000000000..23a1b77221
--- /dev/null
+++ b/src/regress/lib/libc/db/README
@@ -0,0 +1,69 @@
+#       $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".
+
+Fairly large files (the command files) are built in this directory during
+the test runs, and even larger files (the database files) are created in
+"/var/tmp".  If the latter directory doesn't exist, set the environmental
+variable TMPDIR to a directory where the files can be built.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+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
+          associated with the specified key is compared to the specified
+          data value.
+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] 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.
+
+Legal key/data characters are as follows:
+
+D [file]: data file
+        + set the current data value to the contents of the file
+d [data]:
+        + set the current key value to the contents of the line.
+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.
+
+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 or "-" to indicate stdin.
diff --git a/src/regress/lib/libc/db/dbtest.c b/src/regress/lib/libc/db/dbtest.c
new file mode 100644
index 0000000000..c28ec0db5e
--- /dev/null
+++ b/src/regress/lib/libc/db/dbtest.c
@@ -0,0 +1,733 @@
+/*      $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, 1994
+ *      The Regents of the University of California.  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 University 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 REGENTS 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 REGENTS 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 <sys/stat.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#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(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(int argc, char *argv[])
+{
+        extern int optind;
+        extern char *optarg;
+        enum S command, state;
+        DB *dbp;
+        DBT data, key, keydata;
+        size_t len;
+        int ch, oflags, sflag;
+        char *fname, *infoarg, *p, *t, buf[8 * 1024];
+
+        infoarg = NULL;
+        fname = NULL;
+        oflags = O_CREAT | O_RDWR;
+        sflag = 0;
+        while ((ch = getopt(argc, argv, "f:i:lo:s")) != -1)
+                switch (ch) {
+                case 'f':
+                        fname = optarg;
+                        break;
+                case 'i':
+                        infoarg = optarg;
+                        break;
+                case 'l':
+                        oflags |= DB_LOCK;
+                        break;
+                case 'o':
+                        if ((ofd = open(optarg,
+                            O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
+                                dberr("%s: %s", optarg, strerror(errno));
+                        break;
+                case 's':
+                        sflag = 1;
+                        break;
+                case '?':
+                default:
+                        usage();
+                }
+        argc -= optind;
+        argv += optind;
+
+        if (argc != 2)
+                usage();
+
+        /* Set the type. */
+        type = dbtype(*argv++);
+
+        /* Open the descriptor file. */
+        if (strcmp(*argv, "-") && freopen(*argv, "r", stdin) == NULL)
+            dberr("%s: %s", *argv, strerror(errno));
+
+        /* Set up the db structure as necessary. */
+        if (infoarg == NULL)
+                infop = NULL;
+        else
+                for (p = strtok(infoarg, ",\t "); p != NULL;
+                    p = strtok(0, ",\t "))
+                        if (*p != '\0')
+                                infop = setinfo(type, p);
+
+        /*
+         * 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)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)
+                dberr("dbopen: %s", strerror(errno));
+        XXdbp = dbp;
+
+        state = COMMAND;
+        for (lineno = 1;
+            (p = fgets(buf, sizeof(buf), stdin)) != NULL; ++lineno) {
+                /* 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)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        state = KEY;
+                        command = COMPARE;
+                        break;
+                case 'e':                       /* echo */
+                        if (state != COMMAND)
+                                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 ||
+                            write(ofd, "\n", 1) != 1)
+                                dberr("write: %s", strerror(errno));
+                        break;
+                case 'g':                       /* get */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        state = KEY;
+                        command = GET;
+                        break;
+                case 'p':                       /* put */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        state = KEY;
+                        command = PUT;
+                        break;
+                case 'r':                       /* remove */
+                        if (state != COMMAND)
+                                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)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        if (flags == R_CURSOR) {
+                                state = KEY;
+                                command = SEQ;
+                        } else
+                                seq(dbp, &key);
+                        break;
+                case 'f':
+                        flags = setflags(p + 1);
+                        break;
+                case 'D':                       /* data file */
+                        if (state != DATA)
+                                dberr("line %lu: not expecting data", lineno);
+                        data.data = rfile(p + 1, &data.size);
+                        goto ldata;
+                case 'd':                       /* data */
+                        if (state != DATA)
+                                dberr("line %lu: not expecting data", lineno);
+                        data.data = xmalloc(p + 1, len - 1);
+                        data.size = len - 1;
+ldata:                  switch (command) {
+                        case COMPARE:
+                                compare(&keydata, &data);
+                                break;
+                        case PUT:
+                                put(dbp, &key, &data);
+                                break;
+                        default:
+                                dberr("line %lu: command doesn't take data",
+                                    lineno);
+                        }
+                        if (type != DB_RECNO)
+                                free(key.data);
+                        free(data.data);
+                        state = COMMAND;
+                        break;
+                case 'K':                       /* key file */
+                        if (state != KEY)
+                                dberr("line %lu: not expecting a key", lineno);
+                        if (type == DB_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)
+                                dberr("line %lu: not expecting a key", lineno);
+                        if (type == DB_RECNO) {
+                                static recno_t recno;
+                                recno = atoi(p + 1);
+                                key.data = &recno;
+                                key.size = sizeof(recno);
+                        } else {
+                                key.data = xmalloc(p + 1, len - 1);
+                                key.size = len - 1;
+                        }
+lkey:                   switch (command) {
+                        case COMPARE:
+                                getdata(dbp, &key, &keydata);
+                                state = DATA;
+                                break;
+                        case GET:
+                                get(dbp, &key);
+                                if (type != DB_RECNO)
+                                        free(key.data);
+                                state = COMMAND;
+                                break;
+                        case PUT:
+                                state = DATA;
+                                break;
+                        case REMOVE:
+                                rem(dbp, &key);
+                                if ((type != DB_RECNO) && (flags != R_CURSOR))
+                                        free(key.data);
+                                state = COMMAND;
+                                break;
+                        case SEQ:
+                                seq(dbp, &key);
+                                if ((type != DB_RECNO) && (flags != R_CURSOR))
+                                        free(key.data);
+                                state = COMMAND;
+                                break;
+                        default:
+                                dberr("line %lu: command doesn't take a key",
+                                    lineno);
+                        }
+                        break;
+                case 'o':
+                        dump(dbp, p[1] == 'r');
+                        break;
+                default:
+                        dberr("line %lu: %s: unknown command character",
+                            lineno, p);
+                }
+        }
+#ifdef STATISTICS
+        /*
+         * -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))
+                dberr("db->close: %s", strerror(errno));
+        (void)close(ofd);
+        exit(0);
+}
+
+#define NOOVERWRITE     "put failed, would overwrite key\n"
+
+void
+compare(db1, db2)
+        DBT *db1, *db2;
+{
+        register size_t len;
+        register u_char *p1, *p2;
+
+        if (db1->size != db2->size)
+                printf("compare failed: key->data len %lu != data len %lu\n",
+                    db1->size, db2->size);
+
+        len = MIN(db1->size, db2->size);
+        for (p1 = db1->data, p2 = db2->data; len--;)
+                if (*p1++ != *p2++) {
+                        printf("compare failed at offset %d\n",
+                            p1 - (u_char *)db1->data);
+                        break;
+                }
+}
+
+void
+get(dbp, kp)
+        DB *dbp;
+        DBT *kp;
+{
+        DBT data;
+
+        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:
+                dberr("line %lu: get: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 1:
+#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;
+        }
+}
+
+void
+getdata(dbp, kp, dp)
+        DB *dbp;
+        DBT *kp, *dp;
+{
+        switch (dbp->get(dbp, kp, dp, flags)) {
+        case 0:
+                return;
+        case -1:
+                dberr("line %lu: getdata: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 1:
+                dberr("line %lu: getdata failed, no such key", lineno);
+                /* NOTREACHED */
+        }
+}
+
+void
+put(dbp, kp, dp)
+        DB *dbp;
+        DBT *kp, *dp;
+{
+        switch (dbp->put(dbp, kp, dp, flags)) {
+        case 0:
+                break;
+        case -1:
+                dberr("line %lu: put: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 1:
+                (void)write(ofd, NOOVERWRITE, sizeof(NOOVERWRITE) - 1);
+                break;
+        }
+}
+
+void
+rem(dbp, kp)
+        DB *dbp;
+        DBT *kp;
+{
+        switch (dbp->del(dbp, kp, flags)) {
+        case 0:
+                break;
+        case -1:
+                dberr("line %lu: rem: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 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 */
+        }
+}
+
+void
+seq(dbp, kp)
+        DB *dbp;
+        DBT *kp;
+{
+        DBT data;
+
+        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:
+                dberr("line %lu: seq: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 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;
+        }
+}
+
+void
+dump(dbp, rev)
+        DB *dbp;
+        int rev;
+{
+        DBT key, data;
+        int flags, nflags;
+
+        if (rev) {
+                flags = R_LAST;
+                nflags = R_PREV;
+        } else {
+                flags = R_FIRST;
+                nflags = R_NEXT;
+        }
+        for (;; flags = nflags)
+                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:
+                        dberr("line %lu: (dump) seq: %s",
+                            lineno, strerror(errno));
+                        /* NOTREACHED */
+                }
+done:   return;
+}
+        
+u_int
+setflags(s)
+        char *s;
+{
+        char *p;
+
+        for (; isspace(*s); ++s);
+        if (*s == '\n' || *s == '\0')
+                return (0);
+        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);
+
+        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)
+        char *s;
+{
+        if (!strcmp(s, "btree"))
+                return (DB_BTREE);
+        if (!strcmp(s, "hash"))
+                return (DB_HASH);
+        if (!strcmp(s, "recno"))
+                return (DB_RECNO);
+        dberr("%s: unknown type (use btree, hash or recno)", s);
+        /* NOTREACHED */
+}
+
+void *
+setinfo(type, s)
+        DBTYPE type;
+        char *s;
+{
+        static BTREEINFO ib;
+        static HASHINFO ih;
+        static RECNOINFO rh;
+        char *eq;
+
+        if ((eq = strchr(s, '=')) == NULL)
+                dberr("%s: illegal structure set statement", s);
+        *eq++ = '\0';
+        if (!isdigit(*eq))
+                dberr("%s: structure set statement must be a number", s);
+                
+        switch (type) {
+        case DB_BTREE:
+                if (!strcmp("flags", s)) {
+                        ib.flags = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("cachesize", s)) {
+                        ib.cachesize = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("maxkeypage", s)) {
+                        ib.maxkeypage = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("minkeypage", s)) {
+                        ib.minkeypage = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("lorder", s)) {
+                        ib.lorder = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("psize", s)) {
+                        ib.psize = atoi(eq);
+                        return (&ib);
+                }
+                break;
+        case DB_HASH:
+                if (!strcmp("bsize", s)) {
+                        ih.bsize = atoi(eq);
+                        return (&ih);
+                }
+                if (!strcmp("ffactor", s)) {
+                        ih.ffactor = atoi(eq);
+                        return (&ih);
+                }
+                if (!strcmp("nelem", s)) {
+                        ih.nelem = atoi(eq);
+                        return (&ih);
+                }
+                if (!strcmp("cachesize", s)) {
+                        ih.cachesize = atoi(eq);
+                        return (&ih);
+                }
+                if (!strcmp("lorder", s)) {
+                        ih.lorder = atoi(eq);
+                        return (&ih);
+                }
+                break;
+        case DB_RECNO:
+                if (!strcmp("flags", s)) {
+                        rh.flags = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("cachesize", s)) {
+                        rh.cachesize = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("lorder", s)) {
+                        rh.lorder = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("reclen", s)) {
+                        rh.reclen = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("bval", s)) {
+                        rh.bval = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("psize", s)) {
+                        rh.psize = atoi(eq);
+                        return (&rh);
+                }
+                break;
+        }
+        dberr("%s: unknown structure value", s);
+        /* NOTREACHED */
+}
+
+void *
+rfile(name, lenp)
+        char *name;
+        size_t *lenp;
+{
+        struct stat sb;
+        void *p;
+        int fd;
+        char *np;
+
+        for (; isspace(*name); ++name);
+        if ((np = strchr(name, '\n')) != NULL)
+                *np = '\0';
+        if ((fd = open(name, O_RDONLY, 0)) < 0 ||
+            fstat(fd, &sb))
+                dberr("%s: %s\n", name, strerror(errno));
+#ifdef NOT_PORTABLE
+        if (sb.st_size > (off_t)SIZE_T_MAX)
+                dberr("%s: %s\n", name, strerror(E2BIG));
+#endif
+        if ((p = (void *)malloc((u_int)sb.st_size)) == NULL)
+                dberr("%s", strerror(errno));
+        (void)read(fd, p, (int)sb.st_size);
+        *lenp = sb.st_size;
+        (void)close(fd);
+        return (p);
+}
+
+void *
+xmalloc(text, len)
+        char *text;
+        size_t len;
+{
+        void *p;
+
+        if ((p = (void *)malloc(len)) == NULL)
+                dberr("%s", strerror(errno));
+        memmove(p, text, len);
+        return (p);
+}
+
+void
+usage()
+{
+        (void)fprintf(stderr,
+            "usage: dbtest [-l] [-f file] [-i info] [-o file] type script\n");
+        exit(1);
+}
+
+void
+dberr(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        (void)fprintf(stderr, "dbtest: ");
+        (void)vfprintf(stderr, fmt, ap);
+        va_end(ap);
+        (void)fprintf(stderr, "\n");
+        exit(1);
+        /* NOTREACHED */
+}
diff --git a/src/regress/lib/libc/db/run.test b/src/regress/lib/libc/db/run.test
new file mode 100644
index 0000000000..0d6837e360
--- /dev/null
+++ b/src/regress/lib/libc/db/run.test
@@ -0,0 +1,707 @@
+#!/bin/sh -
+#
+#       $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()
+{
+
+        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
+                done
+        else
+                while [ $# -gt 0 ]
+                        do case "$1" in
+                        test*)
+                                $1;;
+                        [0-9]*)
+                                test$1;;
+                        btree)
+                                for t in 1 2 3 7 8 9 10 12 13; do
+                                        test$t
+                                done;;
+                        hash)
+                                for t in 1 2 3 8 13 20; do
+                                        test$t
+                                done;;
+                        recno)
+                                for t in 1 2 3 4 5 6 7 10 11; do
+                                        test$t
+                                done;;
+                        *)
+                                echo "run.test: unknown test $1"
+                                echo "usage: run.test test# | type"
+                                exit 1
+                        esac
+                        shift
+                done
+        fi
+        rm -f $TMP1 $TMP2 $TMP3
+        exit 0
+}
+
+# Take the first hundred entries in the dictionary, and make them
+# be key/data pairs.
+test1()
+{
+        echo "Test 1: btree, hash: small key, small data pairs"
+        sed 200q $DICT > $TMP1
+        for type in btree hash; do
+                rm -f $TMP2 $TMP3
+                for i in `sed 200q $DICT`; do
+                        echo p
+                        echo k$i
+                        echo d$i
+                        echo g
+                        echo k$i
+                done > $TMP2
+                $PROG -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test1: type $type: failed"
+                        exit 1
+                fi
+        done
+        echo "Test 1: recno: small key, small data pairs"
+        rm -f $TMP2 $TMP3
+        sed 200q $DICT |
+        awk '{ 
+                ++i;
+                printf("p\nk%d\nd%s\ng\nk%d\n", i, $0, i);
+        }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test1: type recno: failed"
+                exit 1
+        fi
+}
+
+# Take the first 200 entries in the dictionary, and give them
+# each a medium size data entry.
+test2()
+{
+        echo "Test 2: btree, hash: small key, medium data pairs"
+        mdata=abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
+        echo $mdata |
+        awk '{ for (i = 1; i < 201; ++i) print $0 }' > $TMP1
+        for type in hash btree; do
+                rm -f $TMP2 $TMP3
+                for i in `sed 200q $DICT`; do
+                        echo p
+                        echo k$i
+                        echo d$mdata
+                        echo g
+                        echo k$i
+                done > $TMP2
+                $PROG -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test2: type $type: failed"
+                        exit 1
+                fi
+        done
+        echo "Test 2: recno: small key, medium data pairs"
+        rm -f $TMP2 $TMP3
+        echo $mdata | 
+        awk '{  for (i = 1; i < 201; ++i)
+                printf("p\nk%d\nd%s\ng\nk%d\n", i, $0, i);
+        }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test2: type recno: failed"
+                exit 1
+        fi
+}
+
+# Insert the programs in /bin with their paths as their keys.
+test3()
+{
+        echo "Test 3: hash: small key, big data pairs"
+        rm -f $TMP1
+        (find /bin -type f -print | xargs cat) > $TMP1
+        for type in hash; do
+                rm -f $TMP2 $TMP3
+                for i in `find /bin -type f -print`; do
+                        echo p
+                        echo k$i
+                        echo D$i
+                        echo g
+                        echo k$i
+                done > $TMP2
+                $PROG -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test3: $type: failed"
+                        exit 1
+                fi
+        done
+        echo "Test 3: btree: small key, big data pairs"
+        for psize in 512 16384 65536; do
+                echo "    page size $psize"
+                for type in btree; do
+                        rm -f $TMP2 $TMP3
+                        for i in `find /bin -type f -print`; do
+                                echo p
+                                echo k$i
+                                echo D$i
+                                echo g
+                                echo k$i
+                        done > $TMP2
+                        $PROG -i psize=$psize -o $TMP3 $type $TMP2
+                        if (cmp -s $TMP1 $TMP3) ; then :
+                        else
+                                echo "test3: $type: page size $psize: failed"
+                                exit 1
+                        fi
+                done
+        done
+        echo "Test 3: recno: big data pairs"
+        rm -f $TMP2 $TMP3
+        find /bin -type f -print | 
+        awk '{
+                ++i;
+                printf("p\nk%d\nD%s\ng\nk%d\n", i, $0, i);
+        }' > $TMP2
+        for psize in 512 16384 65536; do
+                echo "    page size $psize"
+                $PROG -i psize=$psize -o $TMP3 recno $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test3: recno: page size $psize: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Do random recno entries.
+test4()
+{
+        echo "Test 4: recno: random entries"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 37; i <= 37 + 88 * 17; i += 17) {
+                        if (i % 41)
+                                s = substr($0, 1, i % 41);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                for (i = 1; i <= 15; ++i) {
+                        if (i % 41)
+                                s = substr($0, 1, i % 41);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                for (i = 19234; i <= 19234 + 61 * 27; i += 27) {
+                        if (i % 41)
+                                s = substr($0, 1, i % 41);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                exit
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+        cat $TMP1 |
+        awk 'BEGIN {
+                        i = 37;
+                        incr = 17;
+                }
+                {
+                        printf("p\nk%d\nd%s\n", i, $0);
+                        if (i == 19234 + 61 * 27)
+                                exit;
+                        if (i == 37 + 88 * 17) {
+                                i = 1;
+                                incr = 1;
+                        } else if (i == 15) {
+                                i = 19234;
+                                incr = 27;
+                        } else
+                                i += incr;
+                }
+                END {
+                        for (i = 37; i <= 37 + 88 * 17; i += 17)
+                                printf("g\nk%d\n", i);
+                        for (i = 1; i <= 15; ++i)
+                                printf("g\nk%d\n", i);
+                        for (i = 19234; i <= 19234 + 61 * 27; i += 27)
+                                printf("g\nk%d\n", i);
+                }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test4: type recno: failed"
+                exit 1
+        fi
+}
+
+# Do reverse order recno entries.
+test5()
+{
+        echo "Test 5: recno: reverse order entries"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk ' {
+                for (i = 1500; i; --i) {
+                        if (i % 34)
+                                s = substr($0, 1, i % 34);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+        cat $TMP1 |
+        awk 'BEGIN {
+                        i = 1500;
+                }
+                {
+                        printf("p\nk%d\nd%s\n", i, $0);
+                        --i;
+                }
+                END {
+                        for (i = 1500; i; --i) 
+                                printf("g\nk%d\n", i);
+                }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test5: type recno: failed"
+                exit 1
+        fi
+}
+                
+# Do alternating order recno entries.
+test6()
+{
+        echo "Test 6: recno: alternating order entries"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk ' {
+                for (i = 1; i < 1200; i += 2) {
+                        if (i % 34)
+                                s = substr($0, 1, i % 34);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                for (i = 2; i < 1200; i += 2) {
+                        if (i % 34)
+                                s = substr($0, 1, i % 34);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+        cat $TMP1 |
+        awk 'BEGIN {
+                        i = 1;
+                        even = 0;
+                }
+                {
+                        printf("p\nk%d\nd%s\n", i, $0);
+                        i += 2;
+                        if (i >= 1200) {
+                                if (even == 1)
+                                        exit;
+                                even = 1;
+                                i = 2;
+                        }
+                }
+                END {
+                        for (i = 1; i < 1200; ++i) 
+                                printf("g\nk%d\n", i);
+                }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        sort -o $TMP1 $TMP1
+        sort -o $TMP3 $TMP3
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test6: type recno: failed"
+                exit 1
+        fi
+}
+
+# Delete cursor record
+test7()
+{
+        echo "Test 7: btree, recno: delete cursor record"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                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("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;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+
+        for type in btree recno; do
+                cat $TMP1 |
+                awk '{
+                        if (i == 120)
+                                exit;
+                        printf("p\nk%d\nd%s\n", ++i, $0);
+                }
+                END {
+                        printf("fR_NEXT\n");
+                        for (i = 1; i <= 120; ++i)
+                                printf("s\n");
+                        printf("fR_CURSOR\ns\nk120\n");
+                        printf("r\n");
+                        printf("fR_NEXT\ns\n");
+                        printf("fR_CURSOR\ns\nk1\n");
+                        printf("r\n");
+                        printf("fR_FIRST\ns\n");
+                }' > $TMP2
+                $PROG -o $TMP3 recno $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test7: type $type: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Make sure that overflow pages are reused.
+test8()
+{
+        echo "Test 8: btree, hash: repeated small key, big data pairs"
+        rm -f $TMP1
+        echo "" | 
+        awk 'BEGIN {
+                for (i = 1; i <= 10; ++i) {
+                        printf("p\nkkey1\nD/bin/sh\n");
+                        printf("p\nkkey2\nD/bin/csh\n");
+                        if (i % 8 == 0) {
+                                printf("c\nkkey2\nD/bin/csh\n");
+                                printf("c\nkkey1\nD/bin/sh\n");
+                                printf("e\t%d of 10 (comparison)\n", i);
+                        } else
+                                printf("e\t%d of 10             \n", i);
+                        printf("r\nkkey1\nr\nkkey2\n");
+                }
+        }' > $TMP1
+        $PROG btree $TMP1
+#       $PROG hash $TMP1
+        # No explicit test for success.
+}
+
+# Test btree duplicate keys
+test9()
+{
+        echo "Test 9: btree: duplicate keys"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 543; ++i)
+                        printf("%05d: input key %d: %s\n", i, i, $0);
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+
+        for type in btree; do
+                cat $TMP1 | 
+                awk '{
+                        if (i++ % 2)
+                                printf("p\nkduplicatekey\nd%s\n", $0);
+                        else
+                                printf("p\nkunique%dkey\nd%s\n", i, $0);
+                }
+                END {
+                                printf("o\n");
+                }' > $TMP2
+                $PROG -iflags=1 -o $TMP3 $type $TMP2
+                sort -o $TMP3 $TMP3
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test9: type $type: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Test use of cursor flags without initialization
+test10()
+{
+        echo "Test 10: btree, recno: test cursor flag use"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 20; ++i)
+                        printf("%05d: input key %d: %s\n", i, i, $0);
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+
+        # Test that R_CURSOR doesn't succeed before cursor initialized
+        for type in btree recno; do
+                cat $TMP1 |
+                awk '{
+                        if (i == 10)
+                                exit;
+                        printf("p\nk%d\nd%s\n", ++i, $0);
+                }
+                END {
+                        printf("fR_CURSOR\nr\n");
+                        printf("eR_CURSOR SHOULD HAVE FAILED\n");
+                }' > $TMP2
+                $PROG -o $TMP3 $type $TMP2 > /dev/null 2>&1
+                if [ -s $TMP3 ] ; then
+                        echo "Test 10: delete: R_CURSOR SHOULD HAVE FAILED"
+                        exit 1
+                fi
+        done
+        for type in btree recno; do
+                cat $TMP1 |
+                awk '{
+                        if (i == 10)
+                                exit;
+                        printf("p\nk%d\nd%s\n", ++i, $0);
+                }
+                END {
+                        printf("fR_CURSOR\np\nk1\ndsome data\n");
+                        printf("eR_CURSOR SHOULD HAVE FAILED\n");
+                }' > $TMP2
+                $PROG -o $TMP3 $type $TMP2 > /dev/null 2>&1
+                if [ -s $TMP3 ] ; then
+                        echo "Test 10: put: R_CURSOR SHOULD HAVE FAILED"
+                        exit 1
+                fi
+        done
+}
+
+# Test insert in reverse order.
+test11()
+{
+        echo "Test 11: recno: reverse order insert"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 779; ++i)
+                        printf("%05d: input key %d: %s\n", i, i, $0);
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+
+        for type in recno; do
+                cat $TMP1 |
+                awk '{
+                        if (i == 0) {
+                                i = 1;
+                                printf("p\nk1\nd%s\n", $0);
+                                printf("%s\n", "fR_IBEFORE");
+                        } else
+                                printf("p\nk1\nd%s\n", $0);
+                }
+                END {
+                                printf("or\n");
+                }' > $TMP2
+                $PROG -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test11: type $type: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Take the first 20000 entries in the dictionary, reverse them, and give
+# them each a small size data entry.  Use a small page size to make sure
+# the btree split code gets hammered.
+test12()
+{
+        echo "Test 12: btree: lots of keys, small page size"
+        mdata=abcdefghijklmnopqrstuvwxy
+        echo $mdata |
+        awk '{ for (i = 1; i < 20001; ++i) print $0 }' > $TMP1
+        for type in btree; do
+                rm -f $TMP2 $TMP3
+                for i in `sed 20000q $DICT | rev`; do
+                        echo p
+                        echo k$i
+                        echo d$mdata
+                        echo g
+                        echo k$i
+                done > $TMP2
+                $PROG -i psize=512 -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test12: type $type: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Test different byte orders.
+test13()
+{
+        echo "Test 13: btree, hash: differing byte orders"
+        sed 50q $DICT > $TMP1
+        for order in 1234 4321; do
+                for type in btree hash; do
+                        rm -f byte.file $TMP2 $TMP3
+                        for i in `sed 50q $DICT`; do
+                                echo p
+                                echo k$i
+                                echo d$i
+                                echo g
+                                echo k$i
+                        done > $TMP2
+                        $PROG -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
+                        if (cmp -s $TMP1 $TMP3) ; then :
+                        else
+                                echo "test13: $type/$order put failed"
+                                exit 1
+                        fi
+                        for i in `sed 50q $DICT`; do
+                                echo g
+                                echo k$i
+                        done > $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"
+                                exit 1
+                        fi
+                done
+        done
+        rm -f byte.file
+}
+
+# Try a variety of bucketsizes and fill factors for hashing
+test20()
+{
+        echo\
+    "Test 20: hash: bucketsize, fill factor; nelem 25000 cachesize 65536"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 10000; ++i) {
+                        if (i % 34)
+                                s = substr($0, 1, i % 34);
+                        else
+                                s = substr($0, 1);
+                        printf("%s\n", s);
+                }
+                exit;
+        }' > $TMP1
+        sed 10000q $DICT |
+        awk 'BEGIN {
+                ds="abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg"
+        }
+        {
+                if (++i % 34)
+                        s = substr(ds, 1, i % 34);
+                else
+                        s = substr(ds, 1);
+                printf("p\nk%s\nd%s\n", $0, s);
+        }' > $TMP2
+        sed 10000q $DICT |
+        awk '{
+                ++i;
+                printf("g\nk%s\n", $0);
+        }' >> $TMP2
+        bsize=256
+        for ffactor in 11 14 21; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=512
+        for ffactor in 21 28 43; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=1024
+        for ffactor in 43 57 85; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=2048
+        for ffactor in 85 114 171; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=4096
+        for ffactor in 171 228 341; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=8192
+        for ffactor in 341 455 683; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+}
+
+main $*
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
new file mode 100644
index 0000000000..89ff51a2e7
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/Makefile
@@ -0,0 +1,8 @@
+#       $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 $
+
+SUBDIR+= except inf infinity round
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/ieeefp/except/Makefile b/src/regress/lib/libc/ieeefp/except/Makefile
new file mode 100644
index 0000000000..205331548f
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/except/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.5 2004/07/22 19:29:42 kettenis Exp $
+
+PROG=except
+
+REGRESS_TARGETS+= fltdiv fltinv fltovf fltund
+
+fltdiv: ${PROG}
+        ./${PROG} fltdiv
+
+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
new file mode 100644
index 0000000000..cc3dcf8e44
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/except/except.c
@@ -0,0 +1,110 @@
+/*      $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>
+
+volatile sig_atomic_t signal_status;
+
+volatile const double one  = 1.0;
+volatile const double zero = 0.0;
+volatile const double huge = DBL_MAX;
+volatile const double tiny = DBL_MIN;
+
+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.
+         */
+        assert(fpgetmask() == 0);
+        assert(fpgetsticky() == 0);
+
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_sigaction = sigfpe;
+        sa.sa_flags = SA_SIGINFO;
+        sigaction(SIGFPE, &sa, NULL);
+        signal_status = 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
new file mode 100644
index 0000000000..9ea6dd8c39
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/round/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.4 2002/02/18 11:25:34 art Exp $
+
+PROG=   round
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/round/round.c b/src/regress/lib/libc/ieeefp/round/round.c
new file mode 100644
index 0000000000..807941ea56
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/round/round.c
@@ -0,0 +1,45 @@
+/*      $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 $    */
+
+/*
+ * Written by J.T. Conklin, Apr 18, 1995
+ * Public domain.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <ieeefp.h>
+#include <float.h>
+
+int
+main(int argc, char *argv[])
+{
+        /*
+         * This test would be better if it actually performed some
+         * calculations to verify the selected rounding mode.  But
+         * this is probably acceptable since the fp{get,set}round
+         * functions usually just get or set the processors fpu
+         * control word.
+         */
+
+        assert(fpgetround() == FP_RN);
+        assert(FLT_ROUNDS == 1);
+
+        assert(fpsetround(FP_RP) == FP_RN);
+        assert(fpgetround() == FP_RP);
+        assert(FLT_ROUNDS == 2);
+
+        assert(fpsetround(FP_RM) == FP_RP);
+        assert(fpgetround() == FP_RM);
+        assert(FLT_ROUNDS == 3);
+
+        assert(fpsetround(FP_RZ) == FP_RM);
+        assert(fpgetround() == FP_RZ);
+        assert(FLT_ROUNDS == 0);
+
+        assert(fpsetround(FP_RN) == FP_RZ);
+        assert(fpgetround() == FP_RN);
+        assert(FLT_ROUNDS == 1);
+
+        exit(0);
+}
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
new file mode 100644
index 0000000000..6b646a46ac
--- /dev/null
+++ b/src/regress/lib/libc/regex/Makefile
@@ -0,0 +1,24 @@
+#       $OpenBSD: Makefile,v 1.8 2011/11/05 15:07:12 otto Exp $
+#       $NetBSD: Makefile,v 1.2 1995/02/16 19:38:45 cgd Exp $
+
+PROG=   re
+SRCS=   main.c split.c debug.c regcomp.c regerror.c regexec.c regfree.c
+.PATH: ${.CURDIR}/../../../../lib/libc/regex
+CLEANFILES += t_exhaust
+
+CFLAGS+= -I${.CURDIR}/../../../../lib/libc/regex -DREDEBUG -DPOSIX_MISTAKE
+
+TESTS=  ${.CURDIR}/tests
+
+REGRESS_TARGETS=do-reg do-reg-long do-reg-backref do-t_exhaust
+
+do-reg: ${PROG}
+        ./re < ${TESTS}
+do-reg-long: ${PROG}
+        ./re -el < ${TESTS}
+do-reg-backref: ${PROG}
+        ./re -er < ${TESTS}
+do-t_exhaust: t_exhaust
+        ./t_exhaust
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/regex/debug.c b/src/regress/lib/libc/regex/debug.c
new file mode 100644
index 0000000000..11129e7249
--- /dev/null
+++ b/src/regress/lib/libc/regex/debug.c
@@ -0,0 +1,245 @@
+/*      $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>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regex2.h"
+#include "debug.ih"
+
+/*
+ - regprint - print a regexp for debugging
+ == void regprint(regex_t *r, FILE *d);
+ */
+void
+regprint(r, d)
+regex_t *r;
+FILE *d;
+{
+        register struct re_guts *g = r->re_g;
+        register int i;
+        register int c;
+        register int last;
+        int nincat[NC];
+
+        fprintf(d, "%ld states, %d categories", (long)g->nstates,
+                                                        g->ncategories);
+        fprintf(d, ", first %ld last %ld", (long)g->firststate,
+                                                (long)g->laststate);
+        if (g->iflags&USEBOL)
+                fprintf(d, ", USEBOL");
+        if (g->iflags&USEEOL)
+                fprintf(d, ", USEEOL");
+        if (g->iflags&BAD)
+                fprintf(d, ", BAD");
+        if (g->nsub > 0)
+                fprintf(d, ", nsub=%ld", (long)g->nsub);
+        if (g->must != NULL)
+                fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
+                                                                g->must);
+        if (g->backrefs)
+                fprintf(d, ", backrefs");
+        if (g->nplus > 0)
+                fprintf(d, ", nplus %ld", (long)g->nplus);
+        fprintf(d, "\n");
+        s_print(g, d);
+        for (i = 0; i < g->ncategories; i++) {
+                nincat[i] = 0;
+                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+                        if (g->categories[c] == i)
+                                nincat[i]++;
+        }
+        fprintf(d, "cc0#%d", nincat[0]);
+        for (i = 1; i < g->ncategories; i++)
+                if (nincat[i] == 1) {
+                        for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+                                if (g->categories[c] == i)
+                                        break;
+                        fprintf(d, ", %d=%s", i, regchar(c));
+                }
+        fprintf(d, "\n");
+        for (i = 1; i < g->ncategories; i++)
+                if (nincat[i] != 1) {
+                        fprintf(d, "cc%d\t", i);
+                        last = -1;
+                        for (c = CHAR_MIN; c <= CHAR_MAX+1; c++)        /* +1 does flush */
+                                if (c <= CHAR_MAX && g->categories[c] == i) {
+                                        if (last < 0) {
+                                                fprintf(d, "%s", regchar(c));
+                                                last = c;
+                                        }
+                                } else {
+                                        if (last >= 0) {
+                                                if (last != c-1)
+                                                        fprintf(d, "-%s",
+                                                                regchar(c-1));
+                                                last = -1;
+                                        }
+                                }
+                        fprintf(d, "\n");
+                }
+}
+
+/*
+ - s_print - print the strip for debugging
+ == static void s_print(register struct re_guts *g, FILE *d);
+ */
+static void
+s_print(g, d)
+register struct re_guts *g;
+FILE *d;
+{
+        register sop *s;
+        register cset *cs;
+        register int i;
+        register int done = 0;
+        register sop opnd;
+        register int col = 0;
+        register int last;
+        register sopno offset = 2;
+#       define  GAP()   {       if (offset % 5 == 0) { \
+                                        if (col > 40) { \
+                                                fprintf(d, "\n\t"); \
+                                                col = 0; \
+                                        } else { \
+                                                fprintf(d, " "); \
+                                                col++; \
+                                        } \
+                                } else \
+                                        col++; \
+                                offset++; \
+                        }
+
+        if (OP(g->strip[0]) != OEND)
+                fprintf(d, "missing initial OEND!\n");
+        for (s = &g->strip[1]; !done; s++) {
+                opnd = OPND(*s);
+                switch (OP(*s)) {
+                case OEND:
+                        fprintf(d, "\n");
+                        done = 1;
+                        break;
+                case OCHAR:
+                        if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
+                                fprintf(d, "\\%c", (char)opnd);
+                        else
+                                fprintf(d, "%s", regchar((char)opnd));
+                        break;
+                case OBOL:
+                        fprintf(d, "^");
+                        break;
+                case OEOL:
+                        fprintf(d, "$");
+                        break;
+                case OBOW:
+                        fprintf(d, "\\{");
+                        break;
+                case OEOW:
+                        fprintf(d, "\\}");
+                        break;
+                case OANY:
+                        fprintf(d, ".");
+                        break;
+                case OANYOF:
+                        fprintf(d, "[(%ld)", (long)opnd);
+                        cs = &g->sets[opnd];
+                        last = -1;
+                        for (i = 0; i < g->csetsize+1; i++)     /* +1 flushes */
+                                if (CHIN(cs, i) && i < g->csetsize) {
+                                        if (last < 0) {
+                                                fprintf(d, "%s", regchar(i));
+                                                last = i;
+                                        }
+                                } else {
+                                        if (last >= 0) {
+                                                if (last != i-1)
+                                                        fprintf(d, "-%s",
+                                                                regchar(i-1));
+                                                last = -1;
+                                        }
+                                }
+                        fprintf(d, "]");
+                        break;
+                case OBACK_:
+                        fprintf(d, "(\\<%ld>", (long)opnd);
+                        break;
+                case O_BACK:
+                        fprintf(d, "<%ld>\\)", (long)opnd);
+                        break;
+                case OPLUS_:
+                        fprintf(d, "(+");
+                        if (OP(*(s+opnd)) != O_PLUS)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        break;
+                case O_PLUS:
+                        if (OP(*(s-opnd)) != OPLUS_)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        fprintf(d, "+)");
+                        break;
+                case OQUEST_:
+                        fprintf(d, "(?");
+                        if (OP(*(s+opnd)) != O_QUEST)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        break;
+                case O_QUEST:
+                        if (OP(*(s-opnd)) != OQUEST_)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        fprintf(d, "?)");
+                        break;
+                case OLPAREN:
+                        fprintf(d, "((<%ld>", (long)opnd);
+                        break;
+                case ORPAREN:
+                        fprintf(d, "<%ld>))", (long)opnd);
+                        break;
+                case OCH_:
+                        fprintf(d, "<");
+                        if (OP(*(s+opnd)) != OOR2)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        break;
+                case OOR1:
+                        if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        fprintf(d, "|");
+                        break;
+                case OOR2:
+                        fprintf(d, "|");
+                        if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        break;
+                case O_CH:
+                        if (OP(*(s-opnd)) != OOR1)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        fprintf(d, ">");
+                        break;
+                default:
+                        fprintf(d, "!%ld(%ld)!", (long)OP(*s), (long)opnd);
+                        break;
+                }
+                if (!done)
+                        GAP();
+        }
+}
+
+/*
+ - regchar - make a character printable
+ == static char *regchar(int ch);
+ */
+static char *                   /* -> representation */
+regchar(ch)
+int ch;
+{
+        static char buf[10];
+
+        if (isprint(ch) || ch == ' ')
+                snprintf(buf, sizeof buf, "%c", ch);
+        else
+                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
new file mode 100644
index 0000000000..9eb313af23
--- /dev/null
+++ b/src/regress/lib/libc/regex/debug.ih
@@ -0,0 +1,17 @@
+/*      $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 ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === debug.c === */
+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
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
diff --git a/src/regress/lib/libc/regex/main.c b/src/regress/lib/libc/regex/main.c
new file mode 100644
index 0000000000..e0ed86f5e8
--- /dev/null
+++ b/src/regress/lib/libc/regex/main.c
@@ -0,0 +1,516 @@
+/*      $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"
+
+char *progname;
+int debug = 0;
+int line = 0;
+int status = 0;
+
+int copts = REG_EXTENDED;
+int eopts = 0;
+regoff_t startoff = 0;
+regoff_t endoff = 0;
+
+
+extern int split(char *, char *[], int, char *);
+extern void regprint(regex_t *, FILE *);
+
+/*
+ - main - do the simple case, hand off to regress() for regression
+ */
+int
+main(int argc, char *argv[])
+
+{
+        regex_t re;
+#       define  NS      10
+        regmatch_t subs[NS];
+        char erbuf[100];
+        int err;
+        size_t len;
+        int c;
+        int errflg = 0;
+        register int i;
+        extern int optind;
+        extern char *optarg;
+
+        progname = argv[0];
+
+        while ((c = getopt(argc, argv, "c:e:S:E:x")) != -1)
+                switch (c) {
+                case 'c':       /* compile options */
+                        copts = options('c', optarg);
+                        break;
+                case 'e':       /* execute options */
+                        eopts = options('e', optarg);
+                        break;
+                case 'S':       /* start offset */
+                        startoff = (regoff_t)atoi(optarg);
+                        break;
+                case 'E':       /* end offset */
+                        endoff = (regoff_t)atoi(optarg);
+                        break;
+                case 'x':       /* Debugging. */
+                        debug++;
+                        break;
+                case '?':
+                default:
+                        errflg++;
+                        break;
+                }
+        if (errflg) {
+                fprintf(stderr, "usage: %s ", progname);
+                fprintf(stderr, "[-c copt][-C][-d] [re]\n");
+                exit(2);
+        }
+
+        if (optind >= argc) {
+                regress(stdin);
+                exit(status);
+        }
+
+        err = regcomp(&re, argv[optind++], copts);
+        if (err) {
+                len = regerror(err, &re, erbuf, sizeof(erbuf));
+                fprintf(stderr, "error %s, %zu/%zu `%s'\n",
+                        eprint(err), len, sizeof(erbuf), erbuf);
+                exit(status);
+        }
+        regprint(&re, stdout);  
+
+        if (optind >= argc) {
+                regfree(&re);
+                exit(status);
+        }
+
+        if (eopts&REG_STARTEND) {
+                subs[0].rm_so = startoff;
+                subs[0].rm_eo = strlen(argv[optind]) - endoff;
+        }
+        err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
+        if (err) {
+                len = regerror(err, &re, erbuf, sizeof(erbuf));
+                fprintf(stderr, "error %s, %zu/%zu `%s'\n",
+                        eprint(err), len, sizeof(erbuf), erbuf);
+                exit(status);
+        }
+        if (!(copts&REG_NOSUB)) {
+                len = (size_t)(subs[0].rm_eo - subs[0].rm_so);
+                if (subs[0].rm_so != -1) {
+                        if (len != 0)
+                                printf("match `%.*s'\n", (int)len,
+                                        argv[optind] + subs[0].rm_so);
+                        else
+                                printf("match `'@%.1s\n",
+                                        argv[optind] + subs[0].rm_so);
+                }
+                for (i = 1; i < NS; i++)
+                        if (subs[i].rm_so != -1)
+                                printf("(%d) `%.*s'\n", i,
+                                        (int)(subs[i].rm_eo - subs[i].rm_so),
+                                        argv[optind] + subs[i].rm_so);
+        }
+        exit(status);
+}
+
+/*
+ - regress - main loop of regression test
+ == void regress(FILE *in);
+ */
+void
+regress(in)
+FILE *in;
+{
+        char inbuf[1000];
+#       define  MAXF    10
+        char *f[MAXF];
+        int nf;
+        int i;
+        char erbuf[100];
+        size_t ne;
+        char *badpat = "invalid regular expression";
+#       define  SHORT   10
+        char *bpname = "REG_BADPAT";
+        regex_t re;
+
+        while (fgets(inbuf, sizeof(inbuf), in) != NULL) {
+                line++;
+                if (inbuf[0] == '#' || inbuf[0] == '\n')
+                        continue;                       /* NOTE CONTINUE */
+                inbuf[strcspn(inbuf, "\n")] = '\0';     /* get rid of stupid \n */
+                if (debug)
+                        fprintf(stdout, "%d:\n", line);
+                nf = split(inbuf, f, MAXF, "\t\t");
+                if (nf < 3) {
+                        fprintf(stderr, "bad input, line %d\n", line);
+                        exit(1);
+                }
+                for (i = 0; i < nf; i++)
+                        if (strcmp(f[i], "\"\"") == 0)
+                                f[i] = "";
+                if (nf <= 3)
+                        f[3] = NULL;
+                if (nf <= 4)
+                        f[4] = NULL;
+                try(f[0], f[1], f[2], f[3], f[4], options('c', f[1]));
+                if (opt('&', f[1]))     /* try with either type of RE */
+                        try(f[0], f[1], f[2], f[3], f[4],
+                                        options('c', f[1]) &~ REG_EXTENDED);
+        }
+
+        ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
+        if (strcmp(erbuf, badpat) != 0 || ne != strlen(badpat)+1) {
+                fprintf(stderr, "end: regerror() test gave `%s' not `%s'\n",
+                                                        erbuf, badpat);
+                status = 1;
+        }
+        ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, (size_t)SHORT);
+        if (strncmp(erbuf, badpat, SHORT-1) != 0 || erbuf[SHORT-1] != '\0' ||
+                                                ne != strlen(badpat)+1) {
+                fprintf(stderr, "end: regerror() short test gave `%s' not `%.*s'\n",
+                                                erbuf, SHORT-1, badpat);
+                status = 1;
+        }
+        ne = regerror(REG_ITOA|REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
+        if (strcmp(erbuf, bpname) != 0 || ne != strlen(bpname)+1) {
+                fprintf(stderr, "end: regerror() ITOA test gave `%s' not `%s'\n",
+                                                erbuf, bpname);
+                status = 1;
+        }
+        re.re_endp = bpname;
+        ne = regerror(REG_ATOI, &re, erbuf, sizeof(erbuf));
+        if (atoi(erbuf) != (int)REG_BADPAT) {
+                fprintf(stderr, "end: regerror() ATOI test gave `%s' not `%ld'\n",
+                                                erbuf, (long)REG_BADPAT);
+                status = 1;
+        } else if (ne != strlen(erbuf)+1) {
+                fprintf(stderr, "end: regerror() ATOI test len(`%s') = %ld\n",
+                                                erbuf, (long)REG_BADPAT);
+                status = 1;
+        }
+}
+
+/*
+ - try - try it, and report on problems
+ == void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
+ */
+void
+try(f0, f1, f2, f3, f4, opts)
+char *f0;
+char *f1;
+char *f2;
+char *f3;
+char *f4;
+int opts;                       /* may not match f1 */
+{
+        regex_t re;
+#       define  NSUBS   10
+        regmatch_t subs[NSUBS];
+#       define  NSHOULD 15
+        char *should[NSHOULD];
+        int nshould;
+        char erbuf[100];
+        int err;
+        int len;
+        char *type = (opts & REG_EXTENDED) ? "ERE" : "BRE";
+        register int i;
+        char *grump;
+        char f0copy[1000];
+        char f2copy[1000];
+
+        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/%zu `%s'\n",
+                                        line, type, eprint(err), len,
+                                        sizeof(erbuf), erbuf);
+                status = 1;
+        } else if (err == 0 && opt('C', f1)) {
+                /* unexpected success */
+                fprintf(stderr, "%d: %s should have given REG_%s\n",
+                                                line, type, f2);
+                status = 1;
+                err = 1;        /* so we won't try regexec */
+        }
+
+        if (err != 0) {
+                regfree(&re);
+                return;
+        }
+
+        strlcpy(f2copy, f2, sizeof f2copy);
+        fixstr(f2copy);
+
+        if (options('e', f1)&REG_STARTEND) {
+                if (strchr(f2, '(') == NULL || strchr(f2, ')') == NULL)
+                        fprintf(stderr, "%d: bad STARTEND syntax\n", line);
+                subs[0].rm_so = strchr(f2, '(') - f2 + 1;
+                subs[0].rm_eo = strchr(f2, ')') - f2;
+        }
+        err = regexec(&re, f2copy, NSUBS, subs, options('e', 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/%zu `%s'\n",
+                                        line, type, eprint(err), len,
+                                        sizeof(erbuf), erbuf);
+                status = 1;
+        } else if (err != 0) {
+                /* nothing more to check */
+        } else if (f3 == NULL) {
+                /* unexpected success */
+                fprintf(stderr, "%d: %s exec should have failed\n",
+                                                line, type);
+                status = 1;
+                err = 1;                /* just on principle */
+        } else if (opts&REG_NOSUB) {
+                /* nothing more to check */
+        } else if ((grump = check(f2, subs[0], f3)) != NULL) {
+                fprintf(stderr, "%d: %s %s\n", line, type, grump);
+                status = 1;
+                err = 1;
+        }
+
+        if (err != 0 || f4 == NULL) {
+                regfree(&re);
+                return;
+        }
+
+        for (i = 1; i < NSHOULD; i++)
+                should[i] = NULL;
+        nshould = split(f4, should+1, NSHOULD-1, ",");
+        if (nshould == 0) {
+                nshould = 1;
+                should[1] = "";
+        }
+        for (i = 1; i < NSUBS; i++) {
+                grump = check(f2, subs[i], should[i]);
+                if (grump != NULL) {
+                        fprintf(stderr, "%d: %s $%d %s\n", line,
+                                                        type, i, grump);
+                        status = 1;
+                        err = 1;
+                }
+        }
+
+        regfree(&re);
+}
+
+/*
+ - options - pick options out of a regression-test string
+ == int options(int type, char *s);
+ */
+int
+options(type, s)
+int type;                       /* 'c' compile, 'e' exec */
+char *s;
+{
+        register char *p;
+        register int o = (type == 'c') ? copts : eopts;
+        register char *legal = (type == 'c') ? "bisnmp" : "^$#tl";
+
+        for (p = s; *p != '\0'; p++)
+                if (strchr(legal, *p) != NULL)
+                        switch (*p) {
+                        case 'b':
+                                o &= ~REG_EXTENDED;
+                                break;
+                        case 'i':
+                                o |= REG_ICASE;
+                                break;
+                        case 's':
+                                o |= REG_NOSUB;
+                                break;
+                        case 'n':
+                                o |= REG_NEWLINE;
+                                break;
+                        case 'm':
+                                o &= ~REG_EXTENDED;
+                                o |= REG_NOSPEC;
+                                break;
+                        case 'p':
+                                o |= REG_PEND;
+                                break;
+                        case '^':
+                                o |= REG_NOTBOL;
+                                break;
+                        case '$':
+                                o |= REG_NOTEOL;
+                                break;
+                        case '#':
+                                o |= REG_STARTEND;
+                                break;
+                        case 't':       /* trace */
+                                o |= REG_TRACE;
+                                break;
+                        case 'l':       /* force long representation */
+                                o |= REG_LARGE;
+                                break;
+                        case 'r':       /* force backref use */
+                                o |= REG_BACKR;
+                                break;
+                        }
+        return(o);
+}
+
+/*
+ - opt - is a particular option in a regression string?
+ == int opt(int c, char *s);
+ */
+int                             /* predicate */
+opt(c, s)
+int c;
+char *s;
+{
+        return(strchr(s, c) != NULL);
+}
+
+/*
+ - fixstr - transform magic characters in strings
+ == void fixstr(register char *p);
+ */
+void
+fixstr(p)
+register char *p;
+{
+        if (p == NULL)
+                return;
+
+        for (; *p != '\0'; p++)
+                if (*p == 'N')
+                        *p = '\n';
+                else if (*p == 'T')
+                        *p = '\t';
+                else if (*p == 'S')
+                        *p = ' ';
+                else if (*p == 'Z')
+                        *p = '\0';
+}
+
+/*
+ - check - check a substring match
+ == char *check(char *str, regmatch_t sub, char *should);
+ */
+char *                          /* NULL or complaint */
+check(str, sub, should)
+char *str;
+regmatch_t sub;
+char *should;
+{
+        register int len;
+        register int shlen;
+        register char *p;
+        static char grump[500];
+        register char *at = NULL;
+
+        if (should != NULL && strcmp(should, "-") == 0)
+                should = NULL;
+        if (should != NULL && should[0] == '@') {
+                at = should + 1;
+                should = "";
+        }
+
+        /* check rm_so and rm_eo for consistency */
+        if (sub.rm_so > sub.rm_eo || (sub.rm_so == -1 && sub.rm_eo != -1) ||
+                                (sub.rm_so != -1 && sub.rm_eo == -1) ||
+                                (sub.rm_so != -1 && sub.rm_so < 0) ||
+                                (sub.rm_eo != -1 && sub.rm_eo < 0) ) {
+                snprintf(grump, sizeof grump,
+                    "start %ld end %ld", (long)sub.rm_so,
+                    (long)sub.rm_eo);
+                return(grump);
+        }
+
+        /* check for no match */
+        if (sub.rm_so == -1 && should == NULL)
+                return(NULL);
+        if (sub.rm_so == -1)
+                return("did not match");
+
+        /* check for in range */
+        if (sub.rm_eo > strlen(str)) {
+                snprintf(grump, sizeof grump,
+                        "start %ld end %ld, past end of string",
+                        (long)sub.rm_so, (long)sub.rm_eo);
+                return(grump);
+        }
+
+        len = (int)(sub.rm_eo - sub.rm_so);
+        shlen = (int)strlen(should);
+        p = str + sub.rm_so;
+
+        /* check for not supposed to match */
+        if (should == NULL) {
+                snprintf(grump, sizeof grump, "matched `%.*s'", len, p);
+                return(grump);
+        }
+
+        /* check for wrong match */
+        if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
+                snprintf(grump, sizeof grump, "matched `%.*s' instead", len, p);
+                return(grump);
+        }
+        if (shlen > 0)
+                return(NULL);
+
+        /* check null match in right place */
+        if (at == NULL)
+                return(NULL);
+        shlen = strlen(at);
+        if (shlen == 0)
+                shlen = 1;      /* force check for end-of-string */
+        if (strncmp(p, at, shlen) != 0) {
+                snprintf(grump, sizeof grump, "matched null at `%.20s'", p);
+                return(grump);
+        }
+        return(NULL);
+}
+
+/*
+ - eprint - convert error number to name
+ == static char *eprint(int err);
+ */
+static char *
+eprint(err)
+int err;
+{
+        static char epbuf[100];
+        size_t len;
+
+        len = regerror(REG_ITOA|err, (regex_t *)NULL, epbuf, sizeof(epbuf));
+        assert(len <= sizeof(epbuf));
+        return(epbuf);
+}
+
+/*
+ - efind - convert error name to number
+ == static int efind(char *name);
+ */
+static int
+efind(name)
+char *name;
+{
+        static char efbuf[100];
+        regex_t re;
+
+        snprintf(efbuf, sizeof efbuf, "REG_%s", name);
+        assert(strlen(efbuf) < sizeof(efbuf));
+        re.re_endp = efbuf;
+        (void) regerror(REG_ATOI, &re, efbuf, sizeof(efbuf));
+        return(atoi(efbuf));
+}
diff --git a/src/regress/lib/libc/regex/main.ih b/src/regress/lib/libc/regex/main.ih
new file mode 100644
index 0000000000..0860e26333
--- /dev/null
+++ b/src/regress/lib/libc/regex/main.ih
@@ -0,0 +1,22 @@
+/*      $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 ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === main.c === */
+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
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
diff --git a/src/regress/lib/libc/regex/split.c b/src/regress/lib/libc/regex/split.c
new file mode 100644
index 0000000000..fcd81a3503
--- /dev/null
+++ b/src/regress/lib/libc/regex/split.c
@@ -0,0 +1,317 @@
+/*      $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(char *string, char *fields[], int nfields, char *sep)
+{
+        register char *p = string;
+        register char c;                        /* latest character */
+        register char sepc = sep[0];
+        register char sepc2;
+        register int fn;
+        register char **fp = fields;
+        register char *sepp;
+        register int trimtrail;
+
+        /* white space */
+        if (sepc == '\0') {
+                while ((c = *p++) == ' ' || c == '\t')
+                        continue;
+                p--;
+                trimtrail = 1;
+                sep = " \t";    /* note, code below knows this is 2 long */
+                sepc = ' ';
+        } else
+                trimtrail = 0;
+        sepc2 = sep[1];         /* now we can safely pick this up */
+
+        /* catch empties */
+        if (*p == '\0')
+                return(0);
+
+        /* single separator */
+        if (sepc2 == '\0') {
+                fn = nfields;
+                for (;;) {
+                        *fp++ = p;
+                        fn--;
+                        if (fn == 0)
+                                break;
+                        while ((c = *p++) != sepc)
+                                if (c == '\0')
+                                        return(nfields - fn);
+                        *(p-1) = '\0';
+                }
+                /* we have overflowed the fields vector -- just count them */
+                fn = nfields;
+                for (;;) {
+                        while ((c = *p++) != sepc)
+                                if (c == '\0')
+                                        return(fn);
+                        fn++;
+                }
+                /* not reached */
+        }
+
+        /* two separators */
+        if (sep[2] == '\0') {
+                fn = nfields;
+                for (;;) {
+                        *fp++ = p;
+                        fn--;
+                        while ((c = *p++) != sepc && c != sepc2)
+                                if (c == '\0') {
+                                        if (trimtrail && **(fp-1) == '\0')
+                                                fn++;
+                                        return(nfields - fn);
+                                }
+                        if (fn == 0)
+                                break;
+                        *(p-1) = '\0';
+                        while ((c = *p++) == sepc || c == sepc2)
+                                continue;
+                        p--;
+                }
+                /* we have overflowed the fields vector -- just count them */
+                fn = nfields;
+                while (c != '\0') {
+                        while ((c = *p++) == sepc || c == sepc2)
+                                continue;
+                        p--;
+                        fn++;
+                        while ((c = *p++) != '\0' && c != sepc && c != sepc2)
+                                continue;
+                }
+                /* might have to trim trailing white space */
+                if (trimtrail) {
+                        p--;
+                        while ((c = *--p) == sepc || c == sepc2)
+                                continue;
+                        p++;
+                        if (*p != '\0') {
+                                if (fn == nfields+1)
+                                        *p = '\0';
+                                fn--;
+                        }
+                }
+                return(fn);
+        }
+
+        /* n separators */
+        fn = 0;
+        for (;;) {
+                if (fn < nfields)
+                        *fp++ = p;
+                fn++;
+                for (;;) {
+                        c = *p++;
+                        if (c == '\0')
+                                return(fn);
+                        sepp = sep;
+                        while ((sepc = *sepp++) != '\0' && sepc != c)
+                                continue;
+                        if (sepc != '\0')       /* it was a separator */
+                                break;
+                }
+                if (fn < nfields)
+                        *(p-1) = '\0';
+                for (;;) {
+                        c = *p++;
+                        sepp = sep;
+                        while ((sepc = *sepp++) != '\0' && sepc != c)
+                                continue;
+                        if (sepc == '\0')       /* it wasn't a separator */
+                                break;
+                }
+                p--;
+        }
+
+        /* not reached */
+}
+
+#ifdef TEST_SPLIT
+
+
+/*
+ * test program
+ * pgm          runs regression
+ * pgm sep      splits stdin lines by sep
+ * pgm str sep  splits str by sep
+ * pgm str sep n        splits str by sep n times
+ */
+int
+main(argc, argv)
+int argc;
+char *argv[];
+{
+        char buf[512];
+        register int n;
+#       define  MNF     10
+        char *fields[MNF];
+
+        if (argc > 4)
+                for (n = atoi(argv[3]); n > 0; n--) {
+                        (void) strlcpy(buf, argv[1], sizeof buf);
+                }
+        else if (argc > 3)
+                for (n = atoi(argv[3]); n > 0; n--) {
+                        (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[strcspn(buf, "\n")] = '\0'; /* stomp newline */
+                        dosplit(buf, argv[1]);
+                }
+        else
+                regress();
+
+        exit(0);
+}
+
+dosplit(string, seps)
+char *string;
+char *seps;
+{
+#       define  NF      5
+        char *fields[NF];
+        register int nf;
+
+        nf = split(string, fields, NF, seps);
+        print(nf, NF, fields);
+}
+
+print(nf, nfp, fields)
+int nf;
+int nfp;
+char *fields[];
+{
+        register int fn;
+        register int bound;
+
+        bound = (nf > nfp) ? nfp : nf;
+        printf("%d:\t", nf);
+        for (fn = 0; fn < bound; fn++)
+                printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
+}
+
+#define RNF     5               /* some table entries know this */
+struct {
+        char *str;
+        char *seps;
+        int nf;
+        char *fi[RNF];
+} tests[] = {
+        "",             " ",    0,      { "" },
+        " ",            " ",    2,      { "", "" },
+        "x",            " ",    1,      { "x" },
+        "xy",           " ",    1,      { "xy" },
+        "x y",          " ",    2,      { "x", "y" },
+        "abc def  g ",  " ",    5,      { "abc", "def", "", "g", "" },
+        "  a bcd",      " ",    4,      { "", "", "a", "bcd" },
+        "a b c d e f",  " ",    6,      { "a", "b", "c", "d", "e f" },
+        " a b c d ",    " ",    6,      { "", "a", "b", "c", "d " },
+
+        "",             " _",   0,      { "" },
+        " ",            " _",   2,      { "", "" },
+        "x",            " _",   1,      { "x" },
+        "x y",          " _",   2,      { "x", "y" },
+        "ab _ cd",      " _",   2,      { "ab", "cd" },
+        " a_b  c ",     " _",   5,      { "", "a", "b", "c", "" },
+        "a b c_d e f",  " _",   6,      { "a", "b", "c", "d", "e f" },
+        " a b c d ",    " _",   6,      { "", "a", "b", "c", "d " },
+
+        "",             " _~",  0,      { "" },
+        " ",            " _~",  2,      { "", "" },
+        "x",            " _~",  1,      { "x" },
+        "x y",          " _~",  2,      { "x", "y" },
+        "ab _~ cd",     " _~",  2,      { "ab", "cd" },
+        " a_b  c~",     " _~",  5,      { "", "a", "b", "c", "" },
+        "a b_c d~e f",  " _~",  6,      { "a", "b", "c", "d", "e f" },
+        "~a b c d ",    " _~",  6,      { "", "a", "b", "c", "d " },
+
+        "",             " _~-", 0,      { "" },
+        " ",            " _~-", 2,      { "", "" },
+        "x",            " _~-", 1,      { "x" },
+        "x y",          " _~-", 2,      { "x", "y" },
+        "ab _~- cd",    " _~-", 2,      { "ab", "cd" },
+        " a_b  c~",     " _~-", 5,      { "", "a", "b", "c", "" },
+        "a b_c-d~e f",  " _~-", 6,      { "a", "b", "c", "d", "e f" },
+        "~a-b c d ",    " _~-", 6,      { "", "a", "b", "c", "d " },
+
+        "",             "  ",   0,      { "" },
+        " ",            "  ",   2,      { "", "" },
+        "x",            "  ",   1,      { "x" },
+        "xy",           "  ",   1,      { "xy" },
+        "x y",          "  ",   2,      { "x", "y" },
+        "abc def  g ",  "  ",   4,      { "abc", "def", "g", "" },
+        "  a bcd",      "  ",   3,      { "", "a", "bcd" },
+        "a b c d e f",  "  ",   6,      { "a", "b", "c", "d", "e f" },
+        " a b c d ",    "  ",   6,      { "", "a", "b", "c", "d " },
+
+        "",             "",     0,      { "" },
+        " ",            "",     0,      { "" },
+        "x",            "",     1,      { "x" },
+        "xy",           "",     1,      { "xy" },
+        "x y",          "",     2,      { "x", "y" },
+        "abc def  g ",  "",     3,      { "abc", "def", "g" },
+        "\t a bcd",     "",     2,      { "a", "bcd" },
+        "  a \tb\t c ", "",     3,      { "a", "b", "c" },
+        "a b c d e ",   "",     5,      { "a", "b", "c", "d", "e" },
+        "a b\tc d e f", "",     6,      { "a", "b", "c", "d", "e f" },
+        " a b c d e f ",        "",     6,      { "a", "b", "c", "d", "e f " },
+
+        NULL,           NULL,   0,      { NULL },
+};
+
+regress()
+{
+        char buf[512];
+        register int n;
+        char *fields[RNF+1];
+        register int nf;
+        register int i;
+        register int printit;
+        register char *f;
+
+        for (n = 0; tests[n].str != NULL; n++) {
+                (void) strlcpy(buf, tests[n].str, sizeof buf);
+                fields[RNF] = NULL;
+                nf = split(buf, fields, RNF, tests[n].seps);
+                printit = 0;
+                if (nf != tests[n].nf) {
+                        printf("split `%s' by `%s' gave %d fields, not %d\n",
+                                tests[n].str, tests[n].seps, nf, tests[n].nf);
+                        printit = 1;
+                } else if (fields[RNF] != NULL) {
+                        printf("split() went beyond array end\n");
+                        printit = 1;
+                } else {
+                        for (i = 0; i < nf && i < RNF; i++) {
+                                f = fields[i];
+                                if (f == NULL)
+                                        f = "(NULL)";
+                                if (strcmp(f, tests[n].fi[i]) != 0) {
+                                        printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
+                                                tests[n].str, tests[n].seps,
+                                                i, fields[i], tests[n].fi[i]);
+                                        printit = 1;
+                                }
+                        }
+                }
+                if (printit)
+                        print(nf, RNF, fields);
+        }
+}
+#endif
diff --git a/src/regress/lib/libc/regex/t_exhaust.c b/src/regress/lib/libc/regex/t_exhaust.c
new file mode 100644
index 0000000000..e4d4e4f5d7
--- /dev/null
+++ b/src/regress/lib/libc/regex/t_exhaust.c
@@ -0,0 +1,186 @@
+/*      $OpenBSD: t_exhaust.c,v 1.2 2011/11/06 15:47:07 otto Exp $      */
+/*      $NetBSD: t_exhaust.c,v 1.2 2011/10/21 00:41:34 christos Exp $   */
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Christos Zoulas.
+ *
+ * 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 by the NetBSD
+ *        Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation 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 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/cdefs.h>
+
+#include <stdio.h>
+#include <regex.h>
+#include <string.h>
+#include <stdlib.h>
+#include <err.h>
+//#include <atf-c.h>
+
+
+static char *
+mkstr(const char *str, size_t len)
+{
+        size_t i, slen = strlen(str);
+        char *p = malloc(slen * len + 1);
+        if (p == NULL)
+                err(1, "malloc");
+        for (i = 0; i < len; i++)
+                strlcpy(&p[i * slen], str, slen * len + 1 - (i * slen));
+        return p;
+}
+
+static char *
+concat(const char *d, const char *s)
+{
+        size_t dlen = strlen(d);
+        size_t slen = strlen(s);
+        char *p = malloc(dlen + slen + 1);
+        strlcpy(p, d, dlen + slen + 1);
+        strlcat(p, s, dlen + slen + 1);
+        return p;
+}
+
+static char *
+p0(size_t len)
+{
+        char *d, *s1, *s2;
+        s1 = mkstr("\\(", len);
+        s2 = concat(s1, ")");
+        free(s1);
+        d = concat("(", s2);
+        free(s2);
+        return d;
+}
+
+static char *
+p1(size_t len)
+{
+        char *d, *s1, *s2, *s3;
+        s1 = mkstr("\\(", 60);
+        s2 = mkstr("(.*)", len);
+        s3 = concat(s1, s2);
+        free(s2);
+        free(s1);
+        s1 = concat(s3, ")");
+        free(s3);
+        d = concat("(", s1);
+        free(s1);
+        return d;
+}
+
+static char *
+ps(const char *m, const char *s, size_t len)
+{
+        char *d, *s1, *s2, *s3;
+        s1 = mkstr(m, len);
+        s2 = mkstr(s, len);
+        s3 = concat(s1, s2);
+        free(s2);
+        free(s1);
+        d = concat("(.?)", s3);
+        free(s3);
+        return d;
+}
+
+static char *
+p2(size_t len)
+{
+        return ps("((.*){0,255}", ")", len);
+}
+
+static char *
+p3(size_t len)
+{
+        return ps("(.\\{0,}", ")", len);
+}
+
+static char *
+p4(size_t len)
+{
+        return ps("((.*){1,255}", ")", len);
+}
+
+static char *
+p5(size_t len)
+{
+        return ps("(", "){1,100}", len);
+}
+
+static char *
+p6(size_t len)
+{
+        char *d, *s1, *s2;
+        s1 = mkstr("(?:(.*)|", len);
+        s2 = concat(s1, "(.*)");
+        free(s1);
+        s1 = mkstr(")", len);
+        d = concat(s2, s1);
+        free(s1);
+        free(s2);
+        return d;
+}
+
+static char *(*patterns[])(size_t) = {
+        p0,
+        p1,
+        p2,
+        p3,
+        p4,
+        p5,
+        p6,
+};
+
+
+main()
+{
+        regex_t re;
+        int e, ret = 0;
+        size_t i;
+
+        for (i = 0; i < sizeof(patterns) / sizeof(patterns[0]); i++) {
+                char *d = (*patterns[i])(9999);
+                e = regcomp(&re, d, i == 6 ? REG_BASIC : REG_EXTENDED);
+                free(d);
+                if (e) {
+                        if (e != REG_ESPACE) {
+                                printf("regcomp returned %d for pattern %zu", e, i);
+                                ret = 1;
+                        }
+                        continue;
+                }
+                (void)regexec(&re, "aaaaaaaa", 0, NULL, 0);
+                regfree(&re);
+        }
+        return ret;
+}
+
diff --git a/src/regress/lib/libc/regex/tests b/src/regress/lib/libc/regex/tests
new file mode 100644
index 0000000000..c827c868b7
--- /dev/null
+++ b/src/regress/lib/libc/regex/tests
@@ -0,0 +1,503 @@
+#       $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
+# Lines are at least three fields, separated by one or more tabs.  "" stands
+# for an empty field.  First field is an RE.  Second field is flags.  If
+# C flag given, regcomp() is expected to fail, and the third field is the
+# error name (minus the leading REG_).
+#
+# Otherwise it is expected to succeed, and the third field is the string to
+# try matching it against.  If there is no fourth field, the match is
+# expected to fail.  If there is a fourth field, it is the substring that
+# the RE is expected to match.  If there is a fifth field, it is a comma-
+# separated list of what the subexpressions should match, with - indicating
+# no match for that one.  In both the fourth and fifth fields, a (sub)field
+# starting with @ indicates that the (sub)expression is expected to match
+# a null string followed by the stuff after the @; this provides a way to
+# test where null strings match.  The character `N' in REs and strings
+# is newline, `S' is space, `T' is tab, `Z' is NUL.
+#
+# The full list of flags:
+#       -       placeholder, does nothing
+#       b       RE is a BRE, not an ERE
+#       &       try it as both an ERE and a BRE
+#       C       regcomp() error expected, third field is error name
+#       i       REG_ICASE
+#       m       ("mundane") REG_NOSPEC
+#       s       REG_NOSUB (not really testable)
+#       n       REG_NEWLINE
+#       ^       REG_NOTBOL
+#       $       REG_NOTEOL
+#       #       REG_STARTEND (see below)
+#       p       REG_PEND
+#
+# For REG_STARTEND, the start/end offsets are those of the substring
+# enclosed in ().
+
+# basics
+a               &       a       a
+abc             &       abc     abc
+abc|de          -       abc     abc
+a|b|c           -       abc     a
+
+# parentheses and perversions thereof
+a(b)c           -       abc     abc
+a\(b\)c         b       abc     abc
+a(              C       EPAREN
+a(              b       a(      a(
+a\(             -       a(      a(
+a\(             bC      EPAREN
+a\(b            bC      EPAREN
+a(b             C       EPAREN
+a(b             b       a(b     a(b
+# gag me with a right parenthesis -- 1003.2 goofed here (my fault, partly)
+a)              -       a)      a)
+)               -       )       )
+# end gagging (in a just world, those *should* give EPAREN)
+a)              b       a)      a)
+a\)             bC      EPAREN
+\)              bC      EPAREN
+a()b            -       ab      ab
+a\(\)b          b       ab      ab
+
+# anchoring and REG_NEWLINE
+^abc$           &       abc     abc
+a^b             -       a^b
+a^b             b       a^b     a^b
+a$b             -       a$b
+a$b             b       a$b     a$b
+^               &       abc     @abc
+$               &       abc     @
+^$              &       ""      @
+$^              -       ""      @
+\($\)\(^\)      b       ""      @
+# stop retching, those are legitimate (although disgusting)
+^^              -       ""      @
+$$              -       ""      @
+b$              &       abNc
+b$              &n      abNc    b
+^b$             &       aNbNc
+^b$             &n      aNbNc   b
+^$              &n      aNNb    @Nb
+^$              n       abc
+^$              n       abcN    @
+$^              n       aNNb    @Nb
+\($\)\(^\)      bn      aNNb    @Nb
+^^              n^      aNNb    @Nb
+$$              n       aNNb    @NN
+^a              ^       a
+a$              $       a
+^a              ^n      aNb
+^b              ^n      aNb     b
+a$              $n      bNa
+b$              $n      bNa     b
+a*(^b$)c*       -       b       b
+a*\(^b$\)c*     b       b       b
+
+# certain syntax errors and non-errors
+|               C       EMPTY
+|               b       |       |
+*               C       BADRPT
+*               b       *       *
++               C       BADRPT
+?               C       BADRPT
+""              &C      EMPTY
+()              -       abc     @abc
+\(\)            b       abc     @abc
+a||b            C       EMPTY
+|ab             C       EMPTY
+ab|             C       EMPTY
+(|a)b           C       EMPTY
+(a|)b           C       EMPTY
+(*a)            C       BADRPT
+(+a)            C       BADRPT
+(?a)            C       BADRPT
+({1}a)          C       BADRPT
+\(\{1\}a\)      bC      BADRPT
+(a|*b)          C       BADRPT
+(a|+b)          C       BADRPT
+(a|?b)          C       BADRPT
+(a|{1}b)        C       BADRPT
+^*              C       BADRPT
+^*              b       *       *
+^+              C       BADRPT
+^?              C       BADRPT
+^{1}            C       BADRPT
+^\{1\}          bC      BADRPT
+
+# metacharacters, backslashes
+a.c             &       abc     abc
+a[bc]d          &       abd     abd
+a\*c            &       a*c     a*c
+a\\b            &       a\b     a\b
+a\\\*b          &       a\*b    a\*b
+a\bc            &       abc     abc
+a\              &C      EESCAPE
+a\\bc           &       a\bc    a\bc
+\{              bC      BADRPT
+a\[b            &       a[b     a[b
+a[b             &C      EBRACK
+# trailing $ is a peculiar special case for the BRE code
+a$              &       a       a
+a$              &       a$
+a\$             &       a
+a\$             &       a$      a$
+a\\$            &       a
+a\\$            &       a$
+a\\$            &       a\$
+a\\$            &       a\      a\
+
+# back references, ugh
+a\(b\)\2c       bC      ESUBREG
+a\(b\1\)c       bC      ESUBREG
+a\(b*\)c\1d     b       abbcbbd abbcbbd bb
+a\(b*\)c\1d     b       abbcbd
+a\(b*\)c\1d     b       abbcbbbd
+^\(.\)\1        b       abc
+a\([bc]\)\1d    b       abcdabbd        abbd    b
+a\(\([bc]\)\2\)*d       b       abbccd  abbccd
+a\(\([bc]\)\2\)*d       b       abbcbd
+# actually, this next one probably ought to fail, but the spec is unclear
+a\(\(b\)*\2\)*d         b       abbbd   abbbd
+# here is a case that no NFA implementation does right
+\(ab*\)[ab]*\1  b       ababaaa ababaaa a
+# check out normal matching in the presence of back refs
+\(a\)\1bcd      b       aabcd   aabcd
+\(a\)\1bc*d     b       aabcd   aabcd
+\(a\)\1bc*d     b       aabd    aabd
+\(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
+ab+c            -       abc     abc
+ab?c            -       abc     abc
+a\(*\)b         b       a*b     a*b
+a\(**\)b        b       ab      ab
+a\(***\)b       bC      BADRPT
+*a              b       *a      *a
+**a             b       a       a
+***a            bC      BADRPT
+
+# the dreaded bounded repetitions
+{               &       {       {
+{abc            &       {abc    {abc
+{1              C       BADRPT
+{1}             C       BADRPT
+a{b             &       a{b     a{b
+a{1}b           -       ab      ab
+a\{1\}b         b       ab      ab
+a{1,}b          -       ab      ab
+a\{1,\}b        b       ab      ab
+a{1,2}b         -       aab     aab
+a\{1,2\}b       b       aab     aab
+a{1             C       EBRACE
+a\{1            bC      EBRACE
+a{1a            C       EBRACE
+a\{1a           bC      EBRACE
+a{1a}           C       BADBR
+a\{1a\}         bC      BADBR
+a{,2}           -       a{,2}   a{,2}
+a\{,2\}         bC      BADBR
+a{,}            -       a{,}    a{,}
+a\{,\}          bC      BADBR
+a{1,x}          C       BADBR
+a\{1,x\}        bC      BADBR
+a{1,x           C       EBRACE
+a\{1,x          bC      EBRACE
+a{300}          C       BADBR
+a\{300\}        bC      BADBR
+a{1,0}          C       BADBR
+a\{1,0\}        bC      BADBR
+ab{0,0}c        -       abcac   ac
+ab\{0,0\}c      b       abcac   ac
+ab{0,1}c        -       abcac   abc
+ab\{0,1\}c      b       abcac   abc
+ab{0,3}c        -       abbcac  abbc
+ab\{0,3\}c      b       abbcac  abbc
+ab{1,1}c        -       acabc   abc
+ab\{1,1\}c      b       acabc   abc
+ab{1,3}c        -       acabc   abc
+ab\{1,3\}c      b       acabc   abc
+ab{2,2}c        -       abcabbc abbc
+ab\{2,2\}c      b       abcabbc abbc
+ab{2,4}c        -       abcabbc abbc
+ab\{2,4\}c      b       abcabbc abbc
+((a{1,10}){1,10}){1,10} -       a       a       a,a
+
+# multiple repetitions
+a**             &C      BADRPT
+a++             C       BADRPT
+a??             C       BADRPT
+a*+             C       BADRPT
+a*?             C       BADRPT
+a+*             C       BADRPT
+a+?             C       BADRPT
+a?*             C       BADRPT
+a?+             C       BADRPT
+a{1}{1}         C       BADRPT
+a*{1}           C       BADRPT
+a+{1}           C       BADRPT
+a?{1}           C       BADRPT
+a{1}*           C       BADRPT
+a{1}+           C       BADRPT
+a{1}?           C       BADRPT
+a*{b}           -       a{b}    a{b}
+a\{1\}\{1\}     bC      BADRPT
+a*\{1\}         bC      BADRPT
+a\{1\}*         bC      BADRPT
+
+# brackets, and numerous perversions thereof
+a[b]c           &       abc     abc
+a[ab]c          &       abc     abc
+a[^ab]c         &       adc     adc
+a[]b]c          &       a]c     a]c
+a[[b]c          &       a[c     a[c
+a[-b]c          &       a-c     a-c
+a[^]b]c         &       adc     adc
+a[^-b]c         &       adc     adc
+a[b-]c          &       a-c     a-c
+a[b             &C      EBRACK
+a[]             &C      EBRACK
+a[1-3]c         &       a2c     a2c
+a[3-1]c         &C      ERANGE
+a[1-3-5]c       &C      ERANGE
+a[[.-.]--]c     &       a-c     a-c
+a[1-            &C      ERANGE
+a[[.            &C      EBRACK
+a[[.x           &C      EBRACK
+a[[.x.          &C      EBRACK
+a[[.x.]         &C      EBRACK
+a[[.x.]]        &       ax      ax
+a[[.x,.]]       &C      ECOLLATE
+a[[.one.]]b     &       a1b     a1b
+a[[.notdef.]]b  &C      ECOLLATE
+a[[.].]]b       &       a]b     a]b
+a[[:alpha:]]c   &       abc     abc
+a[[:notdef:]]c  &C      ECTYPE
+a[[:            &C      EBRACK
+a[[:alpha       &C      EBRACK
+a[[:alpha:]     &C      EBRACK
+a[[:alpha,:]    &C      ECTYPE
+a[[:]:]]b       &C      ECTYPE
+a[[:-:]]b       &C      ECTYPE
+a[[:alph:]]     &C      ECTYPE
+a[[:alphabet:]] &C      ECTYPE
+[[:alnum:]]+    -       -%@a0X- a0X
+[[:alpha:]]+    -       -%@aX0- aX
+[[:blank:]]+    -       aSSTb   SST
+[[:cntrl:]]+    -       aNTb    NT
+[[:digit:]]+    -       a019b   019
+[[:graph:]]+    -       Sa%bS   a%b
+[[:lower:]]+    -       AabC    ab
+[[:print:]]+    -       NaSbN   aSb
+[[:punct:]]+    -       S%-&T   %-&
+[[:space:]]+    -       aSNTb   SNT
+[[:upper:]]+    -       aBCd    BC
+[[:xdigit:]]+   -       p0f3Cq  0f3C
+a[[=b=]]c       &       abc     abc
+a[[=            &C      EBRACK
+a[[=b           &C      EBRACK
+a[[=b=          &C      EBRACK
+a[[=b=]         &C      EBRACK
+a[[=b,=]]       &C      ECOLLATE
+a[[=one=]]b     &       a1b     a1b
+
+# complexities
+a(((b)))c       -       abc     abc
+a(b|(c))d       -       abd     abd
+a(b*|c)d        -       abbd    abbd
+# just gotta have one DFA-buster, of course
+a[ab]{20}       -       aaaaabaaaabaaaabaaaab   aaaaabaaaabaaaabaaaab
+# and an inline expansion in case somebody gets tricky
+a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab]       -       aaaaabaaaabaaaabaaaab   aaaaabaaaabaaaabaaaab
+# and in case somebody just slips in an NFA...
+a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab](wee|week)(knights|night)      -       aaaaabaaaabaaaabaaaabweeknights aaaaabaaaabaaaabaaaabweeknights
+# fish for anomalies as the number of states passes 32
+12345678901234567890123456789   -       a12345678901234567890123456789b 12345678901234567890123456789
+123456789012345678901234567890  -       a123456789012345678901234567890b        123456789012345678901234567890
+1234567890123456789012345678901 -       a1234567890123456789012345678901b       1234567890123456789012345678901
+12345678901234567890123456789012        -       a12345678901234567890123456789012b      12345678901234567890123456789012
+123456789012345678901234567890123       -       a123456789012345678901234567890123b     123456789012345678901234567890123
+# and one really big one, beyond any plausible word width
+1234567890123456789012345678901234567890123456789012345678901234567890  -       a1234567890123456789012345678901234567890123456789012345678901234567890b        1234567890123456789012345678901234567890123456789012345678901234567890
+# fish for problems as brackets go past 8
+[ab][cd][ef][gh][ij][kl][mn]    -       xacegikmoq      acegikm
+[ab][cd][ef][gh][ij][kl][mn][op]        -       xacegikmoq      acegikmo
+[ab][cd][ef][gh][ij][kl][mn][op][qr]    -       xacegikmoqy     acegikmoq
+[ab][cd][ef][gh][ij][kl][mn][op][q]     -       xacegikmoqy     acegikmoq
+
+# subtleties of matching
+abc             &       xabcy   abc
+a\(b\)?c\1d     b       acd
+aBc             i       Abc     Abc
+a[Bc]*d         i       abBCcd  abBCcd
+0[[:upper:]]1   &i      0a1     0a1
+0[[:lower:]]1   &i      0A1     0A1
+a[^b]c          &i      abc
+a[^b]c          &i      aBc
+a[^b]c          &i      adc     adc
+[a]b[c]         -       abc     abc
+[a]b[a]         -       aba     aba
+[abc]b[abc]     -       abc     abc
+[abc]b[abd]     -       abd     abd
+a(b?c)+d        -       accd    accd
+(wee|week)(knights|night)       -       weeknights      weeknights
+(we|wee|week|frob)(knights|night|day)   -       weeknights      weeknights
+a[bc]d          -       xyzaaabcaababdacd       abd
+a[ab]c          -       aaabc   abc
+abc             s       abc     abc
+a*              &       b       @b
+
+# Let's have some fun -- try to match a C comment.
+# first the obvious, which looks okay at first glance...
+/\*.*\*/        -       /*x*/   /*x*/
+# but...
+/\*.*\*/        -       /*x*/y/*z*/     /*x*/y/*z*/
+# okay, we must not match */ inside; try to do that...
+/\*([^*]|\*[^/])*\*/    -       /*x*/   /*x*/
+/\*([^*]|\*[^/])*\*/    -       /*x*/y/*z*/     /*x*/
+# but...
+/\*([^*]|\*[^/])*\*/    -       /*x**/y/*z*/    /*x**/y/*z*/
+# and a still fancier version, which does it right (I think)...
+/\*([^*]|\*+[^*/])*\*+/ -       /*x*/   /*x*/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x*/y/*z*/     /*x*/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x**/y/*z*/    /*x**/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x****/y/*z*/  /*x****/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x**x*/y/*z*/  /*x**x*/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x***x/y/*z*/  /*x***x/y/*z*/
+
+# subexpressions
+a(b)(c)d        -       abcd    abcd    b,c
+a(((b)))c       -       abc     abc     b,b,b
+a(b|(c))d       -       abd     abd     b,-
+a(b*|c|e)d      -       abbd    abbd    bb
+a(b*|c|e)d      -       acd     acd     c
+a(b*|c|e)d      -       ad      ad      @d
+a(b?)c          -       abc     abc     b
+a(b?)c          -       ac      ac      @c
+a(b+)c          -       abc     abc     b
+a(b+)c          -       abbbc   abbbc   bbb
+a(b*)c          -       ac      ac      @c
+(a|ab)(bc([de]+)f|cde)  -       abcdef  abcdef  a,bcdef,de
+# the regression tester only asks for 9 subexpressions
+a(b)(c)(d)(e)(f)(g)(h)(i)(j)k   -       abcdefghijk     abcdefghijk     b,c,d,e,f,g,h,i,j
+a(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)l        -       abcdefghijkl    abcdefghijkl    b,c,d,e,f,g,h,i,j,k
+a([bc]?)c       -       abc     abc     b
+a([bc]?)c       -       ac      ac      @c
+a([bc]+)c       -       abc     abc     b
+a([bc]+)c       -       abcc    abcc    bc
+a([bc]+)bc      -       abcbc   abcbc   bc
+a(bb+|b)b       -       abb     abb     b
+a(bbb+|bb+|b)b  -       abb     abb     b
+a(bbb+|bb+|b)b  -       abbb    abbb    bb
+a(bbb+|bb+|b)bb -       abbb    abbb    b
+(.*).*          -       abcdef  abcdef  abcdef
+(a*)*           -       bc      @b      @b
+
+# do we get the right subexpression when it is used more than once?
+a(b|c)*d        -       ad      ad      -
+a(b|c)*d        -       abcd    abcd    c
+a(b|c)+d        -       abd     abd     b
+a(b|c)+d        -       abcd    abcd    c
+a(b|c?)+d       -       ad      ad      @d
+a(b|c?)+d       -       abcd    abcd    @d
+a(b|c){0,0}d    -       ad      ad      -
+a(b|c){0,1}d    -       ad      ad      -
+a(b|c){0,1}d    -       abd     abd     b
+a(b|c){0,2}d    -       ad      ad      -
+a(b|c){0,2}d    -       abcd    abcd    c
+a(b|c){0,}d     -       ad      ad      -
+a(b|c){0,}d     -       abcd    abcd    c
+a(b|c){1,1}d    -       abd     abd     b
+a(b|c){1,1}d    -       acd     acd     c
+a(b|c){1,2}d    -       abd     abd     b
+a(b|c){1,2}d    -       abcd    abcd    c
+a(b|c){1,}d     -       abd     abd     b
+a(b|c){1,}d     -       abcd    abcd    c
+a(b|c){2,2}d    -       acbd    acbd    b
+a(b|c){2,2}d    -       abcd    abcd    c
+a(b|c){2,4}d    -       abcd    abcd    c
+a(b|c){2,4}d    -       abcbd   abcbd   b
+a(b|c){2,4}d    -       abcbcd  abcbcd  c
+a(b|c){2,}d     -       abcd    abcd    c
+a(b|c){2,}d     -       abcbd   abcbd   b
+a(b+|((c)*))+d  -       abd     abd     @d,@d,-
+a(b+|((c)*))+d  -       abcd    abcd    @d,@d,-
+
+# check out the STARTEND option
+[abc]           &#      a(b)c   b
+[abc]           &#      a(d)c
+[abc]           &#      a(bc)d  b
+[abc]           &#      a(dc)d  c
+.               &#      a()c
+b.*c            &#      b(bc)c  bc
+b.*             &#      b(bc)c  bc
+.*c             &#      b(bc)c  bc
+
+# plain strings, with the NOSPEC flag
+abc             m       abc     abc
+abc             m       xabcy   abc
+abc             m       xyz
+a*b             m       aba*b   a*b
+a*b             m       ab
+""              mC      EMPTY
+
+# cases involving NULs
+aZb             &       a       a
+aZb             &p      a
+aZb             &p#     (aZb)   aZb
+aZ*b            &p#     (ab)    ab
+a.b             &#      (aZb)   aZb
+a.*             &#      (aZb)c  aZb
+
+# word boundaries (ick)
+[[:<:]]a        &       a       a
+[[:<:]]a        &       ba
+[[:<:]]a        &       -a      a
+a[[:>:]]        &       a       a
+a[[:>:]]        &       ab
+a[[:>:]]        &       a-      a
+[[:<:]]a.c[[:>:]]       &       axcd-dayc-dazce-abc     abc
+[[:<:]]a.c[[:>:]]       &       axcd-dayc-dazce-abc-q   abc
+[[:<:]]a.c[[:>:]]       &       axc-dayc-dazce-abc      axc
+[[:<:]]b.c[[:>:]]       &       a_bxc-byc_d-bzc-q       bzc
+[[:<:]].x..[[:>:]]      &       y_xa_-_xb_y-_xc_-axdc   _xc_
+[[:<:]]a_b[[:>:]]       &       x_a_b
+
+# past problems, and suspected problems
+(A[1])|(A[2])|(A[3])|(A[4])|(A[5])|(A[6])|(A[7])|(A[8])|(A[9])|(A[A])   -       A1      A1
+abcdefghijklmnop        i       abcdefghijklmnop        abcdefghijklmnop
+abcdefghijklmnopqrstuv  i       abcdefghijklmnopqrstuv  abcdefghijklmnopqrstuv
+(ALAK)|(ALT[AB])|(CC[123]1)|(CM[123]1)|(GAMC)|(LC[23][EO ])|(SEM[1234])|(SL[ES][12])|(SLWW)|(SLF )|(SLDT)|(VWH[12])|(WH[34][EW])|(WP1[ESN])     -       CC11    CC11
+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
new file mode 100644
index 0000000000..fc68e8d44c
--- /dev/null
+++ b/src/regress/lib/libc/setjmp/Makefile
@@ -0,0 +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
+
+CFLAGS+= -DTEST_SETJMP
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/setjmp/jmptest.c b/src/regress/lib/libc/setjmp/jmptest.c
new file mode 100644
index 0000000000..9512c9ee34
--- /dev/null
+++ b/src/regress/lib/libc/setjmp/jmptest.c
@@ -0,0 +1,136 @@
+/*      $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 $  */
+
+/*
+ * Copyright (c) 1994 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 by Christopher G. Demetriou
+ *      for the NetBSD Project.
+ * 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.
+ */
+
+#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
+#error one of TEST_SETJMP, TEST_U_SETJMP, or TEST_SIGSETJMP must be defined
+#endif
+
+#ifdef TEST_SETJMP
+#define BUF             jmp_buf
+#define SET(b, m)       setjmp(b)
+#define JMP(b, v)       longjmp(b, v)
+#endif
+
+#ifdef TEST_U_SETJMP
+#define BUF             jmp_buf
+#define SET(b, m)       _setjmp(b)
+#define JMP(b, v)       _longjmp(b, v)
+#endif
+
+#ifdef TEST_SIGSETJMP
+#define BUF             sigjmp_buf
+#define SET(b, m)       sigsetjmp(b, m)
+#define JMP(b, v)       siglongjmp(b, v)
+#endif
+
+int expectsignal;
+
+static void
+aborthandler(int signo)
+{
+
+        if (expectsignal)
+                _exit(0);
+        else {
+                warnx("kill(SIGABRT) succeeded");
+                _exit(1);
+        }
+}
+
+int
+main(int argc, char *argv[])
+{
+        struct sigaction sa;
+        BUF jb;
+        sigset_t ss;
+        int i, x;
+
+        i = getpid();
+
+#ifdef TEST_SETJMP
+        expectsignal = 0;
+#endif
+#ifdef TEST_U_SETJMP
+        expectsignal = 1;
+#endif
+#ifdef TEST_SIGSETJMP
+        if (argc != 2 ||
+            (strcmp(argv[1], "save") && strcmp(argv[1], "nosave"))) {
+                fprintf(stderr, "usage: %s [save|nosave]\n", argv[0]);
+                exit(1);
+        }
+        expectsignal = (strcmp(argv[1], "save") != 0);
+#endif
+
+        sa.sa_handler = aborthandler;
+        sigemptyset(&sa.sa_mask);
+        sa.sa_flags = 0;
+        if (sigaction(SIGABRT, &sa, NULL) == -1)
+                err(1, "sigaction failed");
+
+        if (sigemptyset(&ss) == -1)
+                err(1, "sigemptyset failed");
+        if (sigaddset(&ss, SIGABRT) == -1)
+                err(1, "sigaddset failed");
+        if (sigprocmask(SIG_BLOCK, &ss, NULL) == -1)
+                err(1, "sigprocmask (1) failed");
+
+        x = SET(jb, !expectsignal);
+        if (x != 0) {
+                if (x != i)
+                        errx(1, "setjmp returned wrong value");
+
+                kill(i, SIGABRT);
+                if (expectsignal)
+                        errx(1, "kill(SIGABRT) failed");
+                else
+                        exit(0);
+        }
+
+        if (sigprocmask(SIG_UNBLOCK, &ss, NULL) == -1)
+                err(1, "sigprocmask (2) failed");
+
+        JMP(jb, i);
+
+        errx(1, "jmp 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
new file mode 100644
index 0000000000..f88bea3b47
--- /dev/null
+++ b/src/regress/lib/libc/sigsetjmp/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.5 2002/09/02 20:01:43 avsm Exp $
+
+PROG=   sigsetjmptest
+SRCS=   jmptest.c
+
+CFLAGS+= -DTEST_SIGSETJMP
+
+.PATH:  ${.CURDIR}/../setjmp
+
+REGRESS_TARGETS=sigsetjmp-save sigsetjmp-nosave
+
+sigsetjmp-save: ${PROG}
+        ./${PROG} save
+sigsetjmp-nosave: ${PROG}
+        ./${PROG} nosave
+
+.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/stpncpy/Makefile b/src/regress/lib/libc/stpncpy/Makefile
new file mode 100644
index 0000000000..9333934da6
--- /dev/null
+++ b/src/regress/lib/libc/stpncpy/Makefile
@@ -0,0 +1,3 @@
+PROG=stpncpy_test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/stpncpy/stpncpy_test.c b/src/regress/lib/libc/stpncpy/stpncpy_test.c
new file mode 100644
index 0000000000..63b7d25e53
--- /dev/null
+++ b/src/regress/lib/libc/stpncpy/stpncpy_test.c
@@ -0,0 +1,24 @@
+/* $OpenBSD: stpncpy_test.c,v 1.1 2012/07/11 10:46:23 naddy Exp $ */
+
+/*
+ * Public domain, 2012, Christian Weisgerber <naddy@openbsd.org>
+ */
+
+#include <string.h>
+
+int main(void)
+{
+        char dst[8];
+        char *src = "abcdef";
+
+        if (stpncpy(dst, src, 5) != dst + 5)
+                return 1;
+        if (stpncpy(dst, src, 6) != dst + 6)
+                return 1;
+        if (stpncpy(dst, src, 7) != dst + 6)
+                return 1;
+        if (stpncpy(dst, src, 8) != dst + 6)
+                return 1;
+        
+        return 0;
+}
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();
+        }
+}