113 files changed, 4885 insertions, 358 deletions

diff --git a/src/regress/lib/libc/Makefile b/src/regress/lib/libc/Makefile
index 7b65e2c1c5..cca83b0a86 100644
--- a/src/regress/lib/libc/Makefile
+++ b/src/regress/lib/libc/Makefile
@@ -1,6 +1,10 @@
-#       $NetBSD: Makefile,v 1.6 1995/04/24 05:52:15 cgd Exp $
+#       $OpenBSD: Makefile,v 1.28 2008/10/02 12:26:45 millert Exp $
+
+SUBDIR+= _setjmp alloca atexit basename cxa-atexit db dirname fnmatch
+SUBDIR+= fpclassify getaddrinfo getcap getopt_long glob hsearch longjmp
+SUBDIR+= locale malloc netdb popen printf regex setjmp setjmp-signal
+SUBDIR+= sigreturn sigsetjmp sprintf strerror strtod strtonum telldir time vis
 
-SUBDIR+= _setjmp db regex setjmp sigsetjmp
 .if (${MACHINE_ARCH} != "vax")
 SUBDIR+= ieeefp
 .endif
@@ -9,8 +13,6 @@ SUBDIR+= ieeefp
 SUBDIR+= arch/${MACHINE_ARCH}
 .endif
 
-regress: _SUBDIRUSE
-
 install:
 
 .include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/_setjmp/Makefile b/src/regress/lib/libc/_setjmp/Makefile
index c2b9dc1aae..5d58242523 100644
--- a/src/regress/lib/libc/_setjmp/Makefile
+++ b/src/regress/lib/libc/_setjmp/Makefile
@@ -1,16 +1,11 @@
+#       $OpenBSD: Makefile,v 1.3 2002/01/01 23:00:51 art Exp $
 #       $NetBSD: Makefile,v 1.2 1995/04/20 22:38:44 cgd Exp $
 
 PROG=   _setjmptest
 SRCS=   jmptest.c
-NOMAN=  noman, no way, man
 
 CFLAGS+= -DTEST_U_SETJMP
 
 .PATH:  ${.CURDIR}/../setjmp
 
-install:
-
-regress: ${PROG}
-        ./${PROG}
-
-.include <bsd.prog.mk>
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/alloca/Makefile b/src/regress/lib/libc/alloca/Makefile
new file mode 100644
index 0000000000..f31417cda7
--- /dev/null
+++ b/src/regress/lib/libc/alloca/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/02/12 06:49:04 mickey Exp $
+
+PROG=   alloca
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/alloca/alloca.c b/src/regress/lib/libc/alloca/alloca.c
new file mode 100644
index 0000000000..54fa90edae
--- /dev/null
+++ b/src/regress/lib/libc/alloca/alloca.c
@@ -0,0 +1,21 @@
+/*      $OpenBSD: alloca.c,v 1.7 2004/03/10 01:17:45 deraadt Exp $      */
+
+/*      Written by Michael Shalayeff, 2003, Public Domain.      */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int
+main(int argc, char *argv[])
+{
+        char *q, *p;
+
+        p = alloca(41);
+        strlcpy(p, "hellow world", 41);
+
+        q = alloca(53);
+        strlcpy(q, "hellow world", 53);
+
+        exit(strcmp(p, q));
+}
diff --git a/src/regress/lib/libc/arch/alpha/Makefile b/src/regress/lib/libc/arch/alpha/Makefile
index b79a82b0e2..8c4dfb735c 100644
--- a/src/regress/lib/libc/arch/alpha/Makefile
+++ b/src/regress/lib/libc/arch/alpha/Makefile
@@ -1,10 +1,9 @@
+#       $OpenBSD: Makefile,v 1.3 2002/02/23 01:25:11 art Exp $
 #       $NetBSD: Makefile,v 1.1 1995/04/24 05:53:31 cgd Exp $
 
 # do nothing here; none of the tests here can be run automatically
 SUBDIR=
 
-regress: _SUBDIRUSE
-
 install:
 
 .include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/Makefile b/src/regress/lib/libc/arch/alpha/divremtest/Makefile
index bd3b12f537..1da3ac8494 100644
--- a/src/regress/lib/libc/arch/alpha/divremtest/Makefile
+++ b/src/regress/lib/libc/arch/alpha/divremtest/Makefile
@@ -1,3 +1,4 @@
+#       $OpenBSD: Makefile,v 1.2 2001/01/29 02:05:39 niklas Exp $
 #       $NetBSD: Makefile,v 1.1 1995/04/24 05:53:34 cgd Exp $
 
 PROG=   divremtest
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c b/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
index fcf64c9384..3d9e8a6de2 100644
--- a/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
+++ b/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: divremtest.c,v 1.2 2001/01/29 02:05:39 niklas Exp $   */
 /*      $NetBSD: divremtest.c,v 1.1 1995/04/24 05:53:35 cgd Exp $       */
 
 /*
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c b/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
index 65ca17af4c..fcb4765b8c 100644
--- a/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
+++ b/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: mkcases.c,v 1.2 2001/01/29 02:05:39 niklas Exp $      */
 /*      $NetBSD: mkcases.c,v 1.1 1995/04/24 05:53:36 cgd Exp $  */
 
 /*
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c b/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
index ef02d61d70..3b01653f32 100644
--- a/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
+++ b/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: mktestcases.c,v 1.2 2001/01/29 02:05:40 niklas Exp $  */
 /*      $NetBSD: mktestcases.c,v 1.1 1995/04/24 05:53:37 cgd Exp $      */
 
 /*
diff --git a/src/regress/lib/libc/atexit/Makefile b/src/regress/lib/libc/atexit/Makefile
new file mode 100644
index 0000000000..c14b3c7ac4
--- /dev/null
+++ b/src/regress/lib/libc/atexit/Makefile
@@ -0,0 +1,16 @@
+#       $OpenBSD: Makefile,v 1.5 2003/07/31 22:46:59 david Exp $
+
+NOMAN=
+PROG=atexit_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+CLEANFILES+= invalid.out valid.out
+
+run-regress-atexit_test: ${PROG}
+        ./${PROG} -valid 2>${.OBJDIR}/valid.out
+        cmp -s ${.OBJDIR}/valid.out ${.CURDIR}/valid.ok
+        ./${PROG} -invalid-atexit 2>${.OBJDIR}/invalid.out
+        cmp -s ${.OBJDIR}/invalid.out ${.CURDIR}/invalid.ok
+        ./${PROG} -invalid-cleanup 2>${.OBJDIR}/invalid.out
+        cmp -s ${.OBJDIR}/invalid.out ${.CURDIR}/invalid.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/atexit/atexit_test.c b/src/regress/lib/libc/atexit/atexit_test.c
new file mode 100644
index 0000000000..3dd0b62c3e
--- /dev/null
+++ b/src/regress/lib/libc/atexit/atexit_test.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: atexit_test.c,v 1.6 2007/09/03 14:42:44 millert Exp $ */
+
+/*
+ * Copyright (c) 2002 Daniel Hartmeier
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    - Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    - Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Effort sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F30602-01-2-0537.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include "stdlib/atexit.h"
+
+void    handle_first(void);
+void    handle_middle(void);
+void    handle_last(void);
+void    handle_invalid(void);
+void    handle_cleanup(void);
+void    handle_signal(int);
+
+static int counter;
+
+int
+main(int argc, char *argv[])
+{
+        int i;
+
+        if (argc != 2 || (strcmp(argv[1], "-valid") &&
+            strcmp(argv[1], "-invalid-atexit") &&
+            strcmp(argv[1], "-invalid-cleanup"))) {
+                fprintf(stderr, "%s -valid/-invalid-atexit/-invalid-cleanup\n",
+                    argv[0]);
+                return (1);
+        }
+        fprintf(stderr, "main()\n");
+        if (atexit(handle_last)) {
+                perror("atexit(handle_last) failed");
+                return (1);
+        }
+        for (i = 0; i < 65535; ++i) {
+                if (atexit(handle_middle)) {
+                        perror("atexit(handle_middle) failed");
+                        return (1);
+                }
+        }
+        if (atexit(handle_first)) {
+                perror("atexit(handle_first) failed");
+                return (1);
+        }
+        /* this is supposed to segfault */
+        if (!strcmp(argv[1], "-invalid-atexit")) {
+                signal(SIGSEGV, handle_signal);
+                __atexit->fns[0].fn_ptr.std_func = handle_invalid;
+        } else if (!strcmp(argv[1], "-invalid-cleanup")) {
+                struct atexit *p = __atexit;
+
+                signal(SIGSEGV, handle_signal);
+                while (p != NULL && p->next != NULL)
+                        p = p->next;
+                if (p == NULL)
+                        fprintf(stderr, "p == NULL, no page found\n");
+                p->fns[0].fn_ptr.std_func = handle_invalid;
+        }
+        __atexit_register_cleanup(handle_cleanup);
+        counter = 0;
+        fprintf(stderr, "main() returns\n");
+        return (0);
+}
+
+void
+handle_first(void)
+{
+        fprintf(stderr, "handle_first() counter == %i\n", counter);
+}
+
+void
+handle_middle(void)
+{
+        counter++;
+}
+
+void
+handle_last(void)
+{
+        fprintf(stderr, "handle_last() counter == %i\n", counter);
+}
+
+void
+handle_cleanup(void)
+{
+        fprintf(stderr, "handle_cleanup()\n");
+}
+
+void
+handle_invalid(void)
+{
+        fprintf(stderr, "handle_invalid() THIS SHOULD HAVE SEGFAULTED INSTEAD!\n");
+}
+
+void
+handle_signal(int sigraised)
+{
+        switch (sigraised) {
+        case SIGSEGV:
+                fprintf(stderr, "SIGSEGV\n");
+                exit(0);
+        default:
+                fprintf(stderr, "unexpected signal caught\n");
+                exit(1);
+        }
+}
diff --git a/src/regress/lib/libc/atexit/invalid.ok b/src/regress/lib/libc/atexit/invalid.ok
new file mode 100644
index 0000000000..98cbf8c1de
--- /dev/null
+++ b/src/regress/lib/libc/atexit/invalid.ok
@@ -0,0 +1,4 @@
+main()
+SIGSEGV
+handle_first() counter == 0
+handle_last() counter == 65535
diff --git a/src/regress/lib/libc/atexit/valid.ok b/src/regress/lib/libc/atexit/valid.ok
new file mode 100644
index 0000000000..6509e827a7
--- /dev/null
+++ b/src/regress/lib/libc/atexit/valid.ok
@@ -0,0 +1,5 @@
+main()
+main() returns
+handle_first() counter == 0
+handle_last() counter == 65535
+handle_cleanup()
diff --git a/src/regress/lib/libc/basename/Makefile b/src/regress/lib/libc/basename/Makefile
new file mode 100644
index 0000000000..958b06fd11
--- /dev/null
+++ b/src/regress/lib/libc/basename/Makefile
@@ -0,0 +1,3 @@
+PROG=basename_test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/basename/basename_test.c b/src/regress/lib/libc/basename/basename_test.c
new file mode 100644
index 0000000000..34e138c726
--- /dev/null
+++ b/src/regress/lib/libc/basename/basename_test.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2007 Bret S. Lambert <blambert@gsipt.net>
+ *
+ * Public domain.
+ */
+
+#include <sys/param.h>
+
+#include <libgen.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+int
+main(void)
+{
+        char path[2 * MAXPATHLEN];
+        const char *dir = "junk/";
+        const char *fname = "file.name.ext";
+        char *str;
+        int i;
+
+        /* Test normal functioning */
+        strlcpy(path, "/", sizeof(path));
+        strlcat(path, dir, sizeof(path)); 
+        strlcat(path, fname, sizeof(path));
+        str = basename(path);
+        if (strcmp(str, fname) != 0)
+                goto fail;
+
+        /*
+         * There are four states that require special handling:
+         *
+         * 1) path is NULL
+         * 2) path is the empty string
+         * 3) path is composed entirely of slashes
+         * 4) the resulting name is larger than MAXPATHLEN
+         *
+         * The first two cases require that a pointer
+         * to the string "." be returned.
+         *
+         * The third case requires that a pointer
+         * to the string "/" be returned.
+         *
+         * The final case requires that NULL be returned
+         * and errno * be set to ENAMETOOLONG.
+         */
+        /* Case 1 */
+        str = basename(NULL);
+        if (strcmp(str, ".") != 0)
+                goto fail;
+
+        /* Case 2 */
+        strlcpy(path, "", sizeof(path));
+        str = basename(path);
+        if (strcmp(str, ".") != 0)
+                goto fail;
+
+        /* Case 3 */
+        for (i = 0; i < MAXPATHLEN - 1; i++)
+                strlcat(path, "/", sizeof(path));       /* path cleared above */
+        str = basename(path);
+        if (strcmp(str, "/") != 0)
+                goto fail;
+
+        /* Case 4 */
+        strlcpy(path, "/", sizeof(path));
+        strlcat(path, dir, sizeof(path));
+        for (i = 0; i <= MAXPATHLEN; i += sizeof(fname))
+                strlcat(path, fname, sizeof(path));
+        str = basename(path);
+        if (str != NULL || errno != ENAMETOOLONG)
+                goto fail;
+
+        return (0);
+fail:
+        return (1);
+}
diff --git a/src/regress/lib/libc/cxa-atexit/Makefile b/src/regress/lib/libc/cxa-atexit/Makefile
new file mode 100644
index 0000000000..ffd83fe1ca
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/Makefile
@@ -0,0 +1,13 @@
+# $OpenBSD: Makefile,v 1.1 2007/09/03 14:42:44 millert Exp $
+
+.include <bsd.own.mk>
+
+USE_GCC3?=No
+
+.if ${USE_GCC3:L} == "yes"
+SUBDIR+= libgd1 libgd2 test1
+.endif
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/cxa-atexit/libgd1/Makefile b/src/regress/lib/libc/cxa-atexit/libgd1/Makefile
new file mode 100644
index 0000000000..958b726d28
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd1/Makefile
@@ -0,0 +1,9 @@
+# $OpenBSD: Makefile,v 1.1 2007/09/03 14:42:44 millert Exp $
+
+LIB=gd1
+SRCS= gd1.C
+NOPROFILE=yes
+
+regress: all
+
+.include <bsd.lib.mk>
diff --git a/src/regress/lib/libc/cxa-atexit/libgd1/gd1.C b/src/regress/lib/libc/cxa-atexit/libgd1/gd1.C
new file mode 100644
index 0000000000..b3ecd56d91
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd1/gd1.C
@@ -0,0 +1,32 @@
+/*      $OpenBSD: gd1.C,v 1.1 2007/09/03 14:42:44 millert Exp $ */
+
+/*
+ * Copyright (c) 2007 Kurt Miller <kurt@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+
+extern int check1;
+
+struct global_destructor_test_obj1 {
+        inline ~global_destructor_test_obj1() {
+                check1 = 0;
+        }
+};
+
+extern "C" void gd_test1()
+{
+        static global_destructor_test_obj1 gdt;
+}
diff --git a/src/regress/lib/libc/cxa-atexit/libgd1/shlib_version b/src/regress/lib/libc/cxa-atexit/libgd1/shlib_version
new file mode 100644
index 0000000000..97c9f92d6b
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd1/shlib_version
@@ -0,0 +1,2 @@
+major=0
+minor=0
diff --git a/src/regress/lib/libc/cxa-atexit/libgd2/Makefile b/src/regress/lib/libc/cxa-atexit/libgd2/Makefile
new file mode 100644
index 0000000000..7ca21d8bd2
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd2/Makefile
@@ -0,0 +1,9 @@
+# $OpenBSD: Makefile,v 1.1 2007/09/03 14:42:44 millert Exp $
+
+LIB=gd2
+SRCS= gd2.C
+NOPROFILE=yes
+
+regress: all
+
+.include <bsd.lib.mk>
diff --git a/src/regress/lib/libc/cxa-atexit/libgd2/gd2.C b/src/regress/lib/libc/cxa-atexit/libgd2/gd2.C
new file mode 100644
index 0000000000..69e7ffb220
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd2/gd2.C
@@ -0,0 +1,32 @@
+/*      $OpenBSD: gd2.C,v 1.1 2007/09/03 14:42:44 millert Exp $ */
+
+/*
+ * Copyright (c) 2007 Kurt Miller <kurt@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+
+extern int check2;
+
+struct global_destructor_test_obj2 {
+        inline ~global_destructor_test_obj2() {
+                check2 = 0;
+        }
+};
+
+extern "C" void gd_test2()
+{
+        static global_destructor_test_obj2 gdt;
+}
diff --git a/src/regress/lib/libc/cxa-atexit/libgd2/shlib_version b/src/regress/lib/libc/cxa-atexit/libgd2/shlib_version
new file mode 100644
index 0000000000..97c9f92d6b
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/libgd2/shlib_version
@@ -0,0 +1,2 @@
+major=0
+minor=0
diff --git a/src/regress/lib/libc/cxa-atexit/test1/Makefile b/src/regress/lib/libc/cxa-atexit/test1/Makefile
new file mode 100644
index 0000000000..533392d144
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/test1/Makefile
@@ -0,0 +1,29 @@
+# $OpenBSD: Makefile,v 1.1 2007/09/03 14:42:44 millert Exp $
+
+.include <bsd.obj.mk>
+
+GD1_DIR=${.CURDIR}/../libgd1
+GD1_OBJDIR!=    if [ -d $(GD1_DIR)/${__objdir} ]; then \
+                        echo "$(GD1_DIR)/${__objdir}"; \
+                else \
+                        echo "$(GD1_DIR)"; \
+                fi
+
+GD2_DIR=${.CURDIR}/../libgd2
+GD2_OBJDIR!=    if [ -d $(GD2_DIR)/${__objdir} ]; then \
+                        echo "$(GD2_DIR)/${__objdir}"; \
+                else \
+                        echo "$(GD2_DIR)"; \
+                fi
+
+PROG=           test1
+
+SRCS=           test1.C
+
+CFLAGS+=        -DLIBGD1="\"$(GD1_OBJDIR)/libgd1.so\""
+CFLAGS+=        -DLIBGD2="\"$(GD2_OBJDIR)/libgd2.so\""
+LDFLAGS+=       -Wl,-E
+
+NOMAN=
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/cxa-atexit/test1/test1.C b/src/regress/lib/libc/cxa-atexit/test1/test1.C
new file mode 100644
index 0000000000..75fb967a90
--- /dev/null
+++ b/src/regress/lib/libc/cxa-atexit/test1/test1.C
@@ -0,0 +1,63 @@
+/*      $OpenBSD: test1.C,v 1.1 2007/09/03 14:42:44 millert Exp $       */
+
+/*
+ * Copyright (c) 2007 Kurt Miller <kurt@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <dlfcn.h>
+#include <err.h>
+#include <stdio.h>
+
+int check1, check2;
+
+int
+main()
+{
+        void *libgd1, *libgd2;
+        void (*gd_test)();
+        int i;
+
+        for (i=0; i < 50; i++) {
+                check1 = check2 = 1;
+
+                libgd1 = dlopen(LIBGD1, RTLD_LAZY);
+                if (libgd1 == NULL)
+                        errx(1, "dlopen(%s, RTLD_LAZY) FAILED\n", LIBGD1);
+
+                gd_test = (void (*)())dlsym(libgd1, "gd_test1");
+                if (gd_test == NULL)
+                        errx(1, "dlsym(libgd1, \"gd_test1\") FAILED\n");
+
+                (*gd_test)();
+
+                libgd2 = dlopen(LIBGD2, RTLD_LAZY);
+                if (libgd2 == NULL)
+                        errx(1, "dlopen(%s, RTLD_LAZY) FAILED\n", LIBGD2);
+
+                gd_test = (void (*)())dlsym(libgd2, "gd_test2");
+                if (gd_test == NULL)
+                        errx(1, "dlsym(libgd2, \"gd_test2\") FAILED\n");
+
+                (*gd_test)();
+
+                dlclose(libgd1);
+                dlclose(libgd2);
+
+                if (check1 || check2)
+                        errx(1, "global destructors not called\n");
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/db/Makefile b/src/regress/lib/libc/db/Makefile
index 5bf343bf64..7d2882594d 100644
--- a/src/regress/lib/libc/db/Makefile
+++ b/src/regress/lib/libc/db/Makefile
@@ -1,17 +1,22 @@
-#       $NetBSD: Makefile,v 1.10 1995/04/20 22:39:11 cgd Exp $
-#       @(#)Makefile    8.1 (Berkeley) 6/4/93
+#       $OpenBSD: Makefile,v 1.10 2002/09/02 20:01:43 avsm Exp $
+#       $NetBSD: Makefile,v 1.11 1995/12/12 01:54:15 cgd Exp $
 
 PROG=   dbtest
 
 # add -DSTATISTICS to CFLAGS to get usage statistics.  Note that
 # for this to work, libc must be compiled with -DSTATISTICS as well
-CFLAGS= -g -D__DBINTERFACE_PRIVATE -DDEBUG
-NOMAN=  noman
-CLEANFILES+= t1 t2 t3
+CFLAGS+= -g -D__DBINTERFACE_PRIVATE -DDEBUG
+CLEANFILES+= t1 t2 t3 log
 
-install:
+DBTARGETS=1 2 3 4 5 6 7 8 9 10 11 12 13 20
 
-regress:
-        sh ${.CURDIR}/run.test
+.for DT in ${DBTARGETS}
+db-${DT}: ${PROG}
+        sh ${.CURDIR}/run.test ${DT}
+REGRESS_TARGETS+=db-${DT}
+.PHONY: db-${DT}
+.endfor
 
-.include <bsd.prog.mk>
+REGRESS_SLOW_TARGETS+=db-3 db-12 db-20
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/db/README b/src/regress/lib/libc/db/README
index 3b290b09d8..23a1b77221 100644
--- a/src/regress/lib/libc/db/README
+++ b/src/regress/lib/libc/db/README
@@ -1,5 +1,6 @@
-#       $NetBSD: README,v 1.4 1995/04/20 22:39:18 cgd Exp $
-#       @(#)README      8.4 (Berkeley) 6/20/94
+#       $OpenBSD: README,v 1.3 2001/01/29 02:05:40 niklas Exp $
+#       $NetBSD: README,v 1.5 1996/05/03 21:54:19 cgd Exp $
+#       @(#)README      8.8 (Berkeley) 7/31/94
 
 To run the tests, enter "make regress".
 
@@ -9,8 +10,11 @@ the test runs, and even larger files (the database files) are created in
 variable TMPDIR to a directory where the files can be built.
 
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-The script file consists of lines with a initial character which is
-the "command" for that line.  Legal characters are as follows:
+The script file consists of lines with an initial character which is
+the command for that line, or an initial character indicating a key
+or data entry for a previous command.
+
+Legal command characters are as follows:
 
 c: compare a record
         + must be followed by [kK][dD]; the data value in the database
@@ -19,17 +23,24 @@ c: compare a record
 e: echo a string
         + writes out the rest of the line into the output file; if the
           last character is not a carriage-return, a newline is appended.
+f: set the flags for the next command
+        + no value zero's the flags
 g: do a get command
         + must be followed by [kK]
         + writes out the retrieved data DBT.
+o [r]: dump [reverse]
+        + dump the database out, if 'r' is set, in reverse order.
 p: do a put command
         + must be followed by [kK][dD]
 r: do a del command
-        + must be followed by [kK]
+        + must be followed by [kK] unless R_CURSOR flag set.
+S: sync the database
 s: do a seq command
+        + must be followed by [kK] if R_CURSOR flag set.
         + writes out the retrieved data DBT.
-f: set the flags for the next command
-        + no value zero's the flags
+
+Legal key/data characters are as follows:
+
 D [file]: data file
         + set the current data value to the contents of the file
 d [data]:
@@ -38,17 +49,21 @@ K [file]: key file
         + set the current key value to the contents of the file
 k [data]:
         + set the current key value to the contents of the line.
-o [r]: dump [reverse]
-        + dump the database out, if 'r' is set, in reverse order.
+
+Blank lines, lines with leading white space, and lines with leading
+hash marks (#) are ignored.
 
 Options to dbtest are as follows:
 
+        -d: Set the DB_LOCK flag.
         -f: Use the file argument as the database file.
         -i: Use the rest of the argument to set elements in the info
             structure.  If the type is btree, then "-i cachesize=10240"
             will set BTREEINFO.cachesize to 10240.
         -o: The rest of the argument is the output file instead of
             using stdout.
+        -s: Don't delete the database file before opening it, i.e.
+            use the database file from a previous run.
 
-Dbtest requires two arguments, the type of access "hash", "recno" or
-"btree", and the script name.
+Dbtest requires two arguments, the type of access "hash", "recno"
+or "btree", and the script name or "-" to indicate stdin.
diff --git a/src/regress/lib/libc/db/dbtest.c b/src/regress/lib/libc/db/dbtest.c
index 1fcf09af97..8eda40d6b3 100644
--- a/src/regress/lib/libc/db/dbtest.c
+++ b/src/regress/lib/libc/db/dbtest.c
@@ -1,7 +1,8 @@
-/*      $NetBSD: dbtest.c,v 1.7 1995/04/20 22:39:22 cgd Exp $   */
+/*      $OpenBSD: dbtest.c,v 1.11 2003/07/31 21:48:02 deraadt Exp $     */
+/*      $NetBSD: dbtest.c,v 1.8 1996/05/03 21:57:48 cgd Exp $   */
 
 /*-
- * Copyright (c) 1992, 1993
+ * Copyright (c) 1992, 1993, 1994
  *      The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -12,11 +13,7 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
@@ -35,15 +32,15 @@
 
 #ifndef lint
 static char copyright[] =
-"@(#) Copyright (c) 1992, 1993\n\
+"@(#) Copyright (c) 1992, 1993, 1994\n\
         The Regents of the University of California.  All rights reserved.\n";
 #endif /* not lint */
 
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)dbtest.c    8.8 (Berkeley) 2/21/94";
+static char sccsid[] = "@(#)dbtest.c    8.17 (Berkeley) 9/1/94";
 #else
-static char rcsid[] = "$NetBSD: dbtest.c,v 1.7 1995/04/20 22:39:22 cgd Exp $";
+static char rcsid[] = "$OpenBSD: dbtest.c,v 1.11 2003/07/31 21:48:02 deraadt Exp $";
 #endif
 #endif /* not lint */
 
@@ -57,39 +54,41 @@ static char rcsid[] = "$NetBSD: dbtest.c,v 1.7 1995/04/20 22:39:22 cgd Exp $";
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdarg.h>
 #include <unistd.h>
 
 #include <db.h>
 
 enum S { COMMAND, COMPARE, GET, PUT, REMOVE, SEQ, SEQFLAG, KEY, DATA };
 
-void     compare __P((DBT *, DBT *));
-DBTYPE   dbtype __P((char *));
-void     dump __P((DB *, int));
-void     err __P((const char *, ...));
-void     get __P((DB *, DBT *));
-void     getdata __P((DB *, DBT *, DBT *));
-void     put __P((DB *, DBT *, DBT *));
-void     rem __P((DB *, DBT *));
-void    *rfile __P((char *, size_t *));
-void     seq __P((DB *, DBT *));
-u_int    setflags __P((char *));
-void    *setinfo __P((DBTYPE, char *));
-void     usage __P((void));
-void    *xmalloc __P((char *, size_t));
-
-DBTYPE type;
-void *infop;
-u_long lineno;
-u_int flags;
-int ofd = STDOUT_FILENO;
+void     compare(DBT *, DBT *);
+DBTYPE   dbtype(char *);
+void     dump(DB *, int);
+void     dberr(const char *, ...);
+void     get(DB *, DBT *);
+void     getdata(DB *, DBT *, DBT *);
+void     put(DB *, DBT *, DBT *);
+void     rem(DB *, DBT *);
+char    *sflags(int);
+void     synk(DB *);
+void    *rfile(char *, size_t *);
+void     seq(DB *, DBT *);
+u_int    setflags(char *);
+void    *setinfo(DBTYPE, char *);
+void     usage(void);
+void    *xmalloc(char *, size_t);
+
+DBTYPE type;                            /* Database type. */
+void *infop;                            /* Iflags. */
+u_long lineno;                          /* Current line in test script. */
+u_int flags;                            /* Current DB flags. */
+int ofd = STDOUT_FILENO;                /* Standard output fd. */
 
 DB *XXdbp;                              /* Global for gdb. */
+int XXlineno;                           /* Fast breakpoint for gdb. */
 
 int
-main(argc, argv)
-        int argc;
-        char *argv[];
+main(int argc, char *argv[])
 {
         extern int optind;
         extern char *optarg;
@@ -97,14 +96,15 @@ main(argc, argv)
         DB *dbp;
         DBT data, key, keydata;
         size_t len;
-        int ch, oflags;
-        char *fname, *infoarg, *p, buf[8 * 1024];
+        int ch, oflags, sflag;
+        char *fname, *infoarg, *p, *t, buf[8 * 1024];
 
         infoarg = NULL;
         fname = NULL;
         oflags = O_CREAT | O_RDWR;
-        while ((ch = getopt(argc, argv, "f:i:lo:")) != EOF)
-                switch(ch) {
+        sflag = 0;
+        while ((ch = getopt(argc, argv, "f:i:lo:s")) != -1)
+                switch (ch) {
                 case 'f':
                         fname = optarg;
                         break;
@@ -117,7 +117,10 @@ main(argc, argv)
                 case 'o':
                         if ((ofd = open(optarg,
                             O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
-                                err("%s: %s", optarg, strerror(errno));
+                                dberr("%s: %s", optarg, strerror(errno));
+                        break;
+                case 's':
+                        sflag = 1;
                         break;
                 case '?':
                 default:
@@ -133,8 +136,8 @@ main(argc, argv)
         type = dbtype(*argv++);
 
         /* Open the descriptor file. */
-        if (freopen(*argv, "r", stdin) == NULL)
-                err("%s: %s", *argv, strerror(errno));
+        if (strcmp(*argv, "-") && freopen(*argv, "r", stdin) == NULL)
+            dberr("%s: %s", *argv, strerror(errno));
 
         /* Set up the db structure as necessary. */
         if (infoarg == NULL)
@@ -145,61 +148,93 @@ main(argc, argv)
                         if (*p != '\0')
                                 infop = setinfo(type, p);
 
-        /* Open the DB. */
+        /*
+         * Open the DB.  Delete any preexisting copy, you almost never
+         * want it around, and it often screws up tests.
+         */
         if (fname == NULL) {
                 p = getenv("TMPDIR");
                 if (p == NULL)
                         p = "/var/tmp";
-                (void)sprintf(buf, "%s/__dbtest", p);
+                (void)snprintf(buf, sizeof buf, "%s/__dbtest", p);
                 fname = buf;
                 (void)unlink(buf);
-        }
+        } else  if (!sflag)
+                (void)unlink(fname);
+
         if ((dbp = dbopen(fname,
             oflags, S_IRUSR | S_IWUSR, type, infop)) == NULL)
-                err("dbopen: %s", strerror(errno));
+                dberr("dbopen: %s", strerror(errno));
         XXdbp = dbp;
 
         state = COMMAND;
         for (lineno = 1;
             (p = fgets(buf, sizeof(buf), stdin)) != NULL; ++lineno) {
-                len = strlen(buf);
-                switch(*p) {
+                /* Delete the newline, displaying the key/data is easier. */
+                if (ofd == STDOUT_FILENO && (t = strchr(p, '\n')) != NULL)
+                        *t = '\0';
+                if ((len = strlen(buf)) == 0 || isspace(*p) || *p == '#')
+                        continue;
+
+                /* Convenient gdb break point. */
+                if (XXlineno == lineno)
+                        XXlineno = 1;
+                switch (*p) {
                 case 'c':                       /* compare */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         state = KEY;
                         command = COMPARE;
                         break;
                 case 'e':                       /* echo */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         /* Don't display the newline, if CR at EOL. */
                         if (p[len - 2] == '\r')
                                 --len;
-                        if (write(ofd, p + 1, len - 1) != len - 1)
-                                err("write: %s", strerror(errno));
+                        if (write(ofd, p + 1, len - 1) != len - 1 ||
+                            write(ofd, "\n", 1) != 1)
+                                dberr("write: %s", strerror(errno));
                         break;
                 case 'g':                       /* get */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         state = KEY;
                         command = GET;
                         break;
                 case 'p':                       /* put */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         state = KEY;
                         command = PUT;
                         break;
                 case 'r':                       /* remove */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
-                        state = KEY;
-                        command = REMOVE;
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        if (flags == R_CURSOR) {
+                                rem(dbp, &key);
+                                state = COMMAND;
+                        } else {
+                                state = KEY;
+                                command = REMOVE;
+                        }
+                        break;
+                case 'S':                       /* sync */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        synk(dbp);
+                        state = COMMAND;
                         break;
                 case 's':                       /* seq */
                         if (state != COMMAND)
-                                err("line %lu: not expecting command", lineno);
+                                dberr("line %lu: not expecting command",
+                                    lineno);
                         if (flags == R_CURSOR) {
                                 state = KEY;
                                 command = SEQ;
@@ -211,15 +246,15 @@ main(argc, argv)
                         break;
                 case 'D':                       /* data file */
                         if (state != DATA)
-                                err("line %lu: not expecting data", lineno);
+                                dberr("line %lu: not expecting data", lineno);
                         data.data = rfile(p + 1, &data.size);
                         goto ldata;
                 case 'd':                       /* data */
                         if (state != DATA)
-                                err("line %lu: not expecting data", lineno);
+                                dberr("line %lu: not expecting data", lineno);
                         data.data = xmalloc(p + 1, len - 1);
                         data.size = len - 1;
-ldata:                  switch(command) {
+ldata:                  switch (command) {
                         case COMPARE:
                                 compare(&keydata, &data);
                                 break;
@@ -227,7 +262,7 @@ ldata:			switch(command) {
                                 put(dbp, &key, &data);
                                 break;
                         default:
-                                err("line %lu: command doesn't take data",
+                                dberr("line %lu: command doesn't take data",
                                     lineno);
                         }
                         if (type != DB_RECNO)
@@ -237,15 +272,15 @@ ldata:			switch(command) {
                         break;
                 case 'K':                       /* key file */
                         if (state != KEY)
-                                err("line %lu: not expecting a key", lineno);
+                                dberr("line %lu: not expecting a key", lineno);
                         if (type == DB_RECNO)
-                                err("line %lu: 'K' not available for recno",
+                                dberr("line %lu: 'K' not available for recno",
                                     lineno);
                         key.data = rfile(p + 1, &key.size);
                         goto lkey;
                 case 'k':                       /* key */
                         if (state != KEY)
-                                err("line %lu: not expecting a key", lineno);
+                                dberr("line %lu: not expecting a key", lineno);
                         if (type == DB_RECNO) {
                                 static recno_t recno;
                                 recno = atoi(p + 1);
@@ -255,7 +290,7 @@ ldata:			switch(command) {
                                 key.data = xmalloc(p + 1, len - 1);
                                 key.size = len - 1;
                         }
-lkey:                   switch(command) {
+lkey:                   switch (command) {
                         case COMPARE:
                                 getdata(dbp, &key, &keydata);
                                 state = DATA;
@@ -271,18 +306,18 @@ lkey:			switch(command) {
                                 break;
                         case REMOVE:
                                 rem(dbp, &key);
-                                if (type != DB_RECNO)
+                                if ((type != DB_RECNO) && (flags != R_CURSOR))
                                         free(key.data);
                                 state = COMMAND;
                                 break;
                         case SEQ:
                                 seq(dbp, &key);
-                                if (type != DB_RECNO)
+                                if ((type != DB_RECNO) && (flags != R_CURSOR))
                                         free(key.data);
                                 state = COMMAND;
                                 break;
                         default:
-                                err("line %lu: command doesn't take a key",
+                                dberr("line %lu: command doesn't take a key",
                                     lineno);
                         }
                         break;
@@ -290,22 +325,25 @@ lkey:			switch(command) {
                         dump(dbp, p[1] == 'r');
                         break;
                 default:
-                        err("line %lu: %s: unknown command character",
-                            p, lineno);
+                        dberr("line %lu: %s: unknown command character",
+                            lineno, p);
                 }
         }
 #ifdef STATISTICS
-        if (type == DB_BTREE)
+        /*
+         * -l must be used (DB_LOCK must be set) for this to be
+         * used, otherwise a page will be locked and it will fail.
+         */
+        if (type == DB_BTREE && oflags & DB_LOCK)
                 __bt_stat(dbp);
 #endif
         if (dbp->close(dbp))
-                err("db->close: %s", strerror(errno));
+                dberr("db->close: %s", strerror(errno));
         (void)close(ofd);
         exit(0);
 }
 
 #define NOOVERWRITE     "put failed, would overwrite key\n"
-#define NOSUCHKEY       "get failed, no such key\n"
 
 void
 compare(db1, db2)
@@ -334,17 +372,23 @@ get(dbp, kp)
 {
         DBT data;
 
-        switch(dbp->get(dbp, kp, &data, flags)) {
+        switch (dbp->get(dbp, kp, &data, flags)) {
         case 0:
                 (void)write(ofd, data.data, data.size);
+                if (ofd == STDOUT_FILENO)
+                        (void)write(ofd, "\n", 1);
                 break;
         case -1:
-                err("line %lu: get: %s", lineno, strerror(errno));
+                dberr("line %lu: get: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
-                (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
-                (void)fprintf(stderr, "%d: %.*s: %s\n", 
-                    lineno, kp->size, kp->data, NOSUCHKEY);
+#define NOSUCHKEY       "get failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else
+                        (void)fprintf(stderr, "%d: %.*s: %s",
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+#undef  NOSUCHKEY
                 break;
         }
 }
@@ -354,14 +398,14 @@ getdata(dbp, kp, dp)
         DB *dbp;
         DBT *kp, *dp;
 {
-        switch(dbp->get(dbp, kp, dp, flags)) {
+        switch (dbp->get(dbp, kp, dp, flags)) {
         case 0:
                 return;
         case -1:
-                err("line %lu: getdata: %s", lineno, strerror(errno));
+                dberr("line %lu: getdata: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
-                err("line %lu: get failed, no such key", lineno);
+                dberr("line %lu: getdata failed, no such key", lineno);
                 /* NOTREACHED */
         }
 }
@@ -371,11 +415,11 @@ put(dbp, kp, dp)
         DB *dbp;
         DBT *kp, *dp;
 {
-        switch(dbp->put(dbp, kp, dp, flags)) {
+        switch (dbp->put(dbp, kp, dp, flags)) {
         case 0:
                 break;
         case -1:
-                err("line %lu: put: %s", lineno, strerror(errno));
+                dberr("line %lu: put: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
                 (void)write(ofd, NOOVERWRITE, sizeof(NOOVERWRITE) - 1);
@@ -388,34 +432,67 @@ rem(dbp, kp)
         DB *dbp;
         DBT *kp;
 {
-        switch(dbp->del(dbp, kp, flags)) {
+        switch (dbp->del(dbp, kp, flags)) {
         case 0:
                 break;
         case -1:
-                err("line %lu: get: %s", lineno, strerror(errno));
+                dberr("line %lu: rem: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
-                (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+#define NOSUCHKEY       "rem failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else if (flags != R_CURSOR)
+                        (void)fprintf(stderr, "%d: %.*s: %s", 
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+                else
+                        (void)fprintf(stderr,
+                            "%d: rem of cursor failed\n", lineno);
+#undef  NOSUCHKEY
                 break;
         }
 }
 
 void
+synk(dbp)
+        DB *dbp;
+{
+        switch (dbp->sync(dbp, flags)) {
+        case 0:
+                break;
+        case -1:
+                dberr("line %lu: synk: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        }
+}
+
+void
 seq(dbp, kp)
         DB *dbp;
         DBT *kp;
 {
         DBT data;
 
-        switch(dbp->seq(dbp, kp, &data, flags)) {
+        switch (dbp->seq(dbp, kp, &data, flags)) {
         case 0:
                 (void)write(ofd, data.data, data.size);
+                if (ofd == STDOUT_FILENO)
+                        (void)write(ofd, "\n", 1);
                 break;
         case -1:
-                err("line %lu: seq: %s", lineno, strerror(errno));
+                dberr("line %lu: seq: %s", lineno, strerror(errno));
                 /* NOTREACHED */
         case 1:
-                (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+#define NOSUCHKEY       "seq failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else if (flags == R_CURSOR)
+                        (void)fprintf(stderr, "%d: %.*s: %s", 
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+                else
+                        (void)fprintf(stderr,
+                            "%d: seq (%s) failed\n", lineno, sflags(flags));
+#undef  NOSUCHKEY
                 break;
         }
 }
@@ -436,14 +513,16 @@ dump(dbp, rev)
                 nflags = R_NEXT;
         }
         for (;; flags = nflags)
-                switch(dbp->seq(dbp, &key, &data, flags)) {
+                switch (dbp->seq(dbp, &key, &data, flags)) {
                 case 0:
                         (void)write(ofd, data.data, data.size);
+                        if (ofd == STDOUT_FILENO)
+                                (void)write(ofd, "\n", 1);
                         break;
                 case 1:
                         goto done;
                 case -1:
-                        err("line %lu: (dump) seq: %s",
+                        dberr("line %lu: (dump) seq: %s",
                             lineno, strerror(errno));
                         /* NOTREACHED */
                 }
@@ -454,34 +533,45 @@ u_int
 setflags(s)
         char *s;
 {
-        char *p, *index();
+        char *p;
 
         for (; isspace(*s); ++s);
-        if (*s == '\n')
+        if (*s == '\n' || *s == '\0')
                 return (0);
-        if ((p = index(s, '\n')) != NULL)
+        if ((p = strchr(s, '\n')) != NULL)
                 *p = '\0';
-        if (!strcmp(s, "R_CURSOR"))
-                return (R_CURSOR);
-        if (!strcmp(s, "R_FIRST"))
-                return (R_FIRST);
-        if (!strcmp(s, "R_IAFTER"))
-                return (R_IAFTER);
-        if (!strcmp(s, "R_IBEFORE"))
-                return (R_IBEFORE);
-        if (!strcmp(s, "R_LAST"))
-                return (R_LAST);
-        if (!strcmp(s, "R_NEXT"))
-                return (R_NEXT);
-        if (!strcmp(s, "R_NOOVERWRITE"))
-                return (R_NOOVERWRITE);
-        if (!strcmp(s, "R_PREV"))
-                return (R_PREV);
-        if (!strcmp(s, "R_SETCURSOR"))
-                return (R_SETCURSOR);
-        err("line %lu: %s: unknown flag", lineno, s);
+        if (!strcmp(s, "R_CURSOR"))             return (R_CURSOR);
+        if (!strcmp(s, "R_FIRST"))              return (R_FIRST);
+        if (!strcmp(s, "R_IAFTER"))             return (R_IAFTER);
+        if (!strcmp(s, "R_IBEFORE"))            return (R_IBEFORE);
+        if (!strcmp(s, "R_LAST"))               return (R_LAST);
+        if (!strcmp(s, "R_NEXT"))               return (R_NEXT);
+        if (!strcmp(s, "R_NOOVERWRITE"))        return (R_NOOVERWRITE);
+        if (!strcmp(s, "R_PREV"))               return (R_PREV);
+        if (!strcmp(s, "R_SETCURSOR"))          return (R_SETCURSOR);
+
+        dberr("line %lu: %s: unknown flag", lineno, s);
         /* NOTREACHED */
 }
+
+char *
+sflags(flags)
+        int flags;
+{
+        switch (flags) {
+        case R_CURSOR:          return ("R_CURSOR");
+        case R_FIRST:           return ("R_FIRST");
+        case R_IAFTER:          return ("R_IAFTER");
+        case R_IBEFORE:         return ("R_IBEFORE");
+        case R_LAST:            return ("R_LAST");
+        case R_NEXT:            return ("R_NEXT");
+        case R_NOOVERWRITE:     return ("R_NOOVERWRITE");
+        case R_PREV:            return ("R_PREV");
+        case R_SETCURSOR:       return ("R_SETCURSOR");
+        }
+
+        return ("UNKNOWN!");
+}
         
 DBTYPE
 dbtype(s)
@@ -493,7 +583,7 @@ dbtype(s)
                 return (DB_HASH);
         if (!strcmp(s, "recno"))
                 return (DB_RECNO);
-        err("%s: unknown type (use btree, hash or recno)", s);
+        dberr("%s: unknown type (use btree, hash or recno)", s);
         /* NOTREACHED */
 }
 
@@ -505,15 +595,15 @@ setinfo(type, s)
         static BTREEINFO ib;
         static HASHINFO ih;
         static RECNOINFO rh;
-        char *eq, *index();
+        char *eq;
 
-        if ((eq = index(s, '=')) == NULL)
-                err("%s: illegal structure set statement", s);
+        if ((eq = strchr(s, '=')) == NULL)
+                dberr("%s: illegal structure set statement", s);
         *eq++ = '\0';
         if (!isdigit(*eq))
-                err("%s: structure set statement must be a number", s);
+                dberr("%s: structure set statement must be a number", s);
                 
-        switch(type) {
+        switch (type) {
         case DB_BTREE:
                 if (!strcmp("flags", s)) {
                         ib.flags = atoi(eq);
@@ -589,7 +679,7 @@ setinfo(type, s)
                 }
                 break;
         }
-        err("%s: unknown structure value", s);
+        dberr("%s: unknown structure value", s);
         /* NOTREACHED */
 }
 
@@ -601,20 +691,20 @@ rfile(name, lenp)
         struct stat sb;
         void *p;
         int fd;
-        char *np, *index();
+        char *np;
 
         for (; isspace(*name); ++name);
-        if ((np = index(name, '\n')) != NULL)
+        if ((np = strchr(name, '\n')) != NULL)
                 *np = '\0';
         if ((fd = open(name, O_RDONLY, 0)) < 0 ||
             fstat(fd, &sb))
-                err("%s: %s\n", name, strerror(errno));
+                dberr("%s: %s\n", name, strerror(errno));
 #ifdef NOT_PORTABLE
         if (sb.st_size > (off_t)SIZE_T_MAX)
-                err("%s: %s\n", name, strerror(E2BIG));
+                dberr("%s: %s\n", name, strerror(E2BIG));
 #endif
         if ((p = (void *)malloc((u_int)sb.st_size)) == NULL)
-                err("%s", strerror(errno));
+                dberr("%s", strerror(errno));
         (void)read(fd, p, (int)sb.st_size);
         *lenp = sb.st_size;
         (void)close(fd);
@@ -629,7 +719,7 @@ xmalloc(text, len)
         void *p;
 
         if ((p = (void *)malloc(len)) == NULL)
-                err("%s", strerror(errno));
+                dberr("%s", strerror(errno));
         memmove(p, text, len);
         return (p);
 }
@@ -642,27 +732,12 @@ usage()
         exit(1);
 }
 
-#if __STDC__
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
-
 void
-#if __STDC__
-err(const char *fmt, ...)
-#else
-err(fmt, va_alist)
-        char *fmt;
-        va_dcl
-#endif
+dberr(const char *fmt, ...)
 {
         va_list ap;
-#if __STDC__
+
         va_start(ap, fmt);
-#else
-        va_start(ap);
-#endif
         (void)fprintf(stderr, "dbtest: ");
         (void)vfprintf(stderr, fmt, ap);
         va_end(ap);
diff --git a/src/regress/lib/libc/db/run.test b/src/regress/lib/libc/db/run.test
index 4073310a31..0d6837e360 100644
--- a/src/regress/lib/libc/db/run.test
+++ b/src/regress/lib/libc/db/run.test
@@ -1,19 +1,28 @@
 #!/bin/sh -
-#       $NetBSD: run.test,v 1.7 1995/04/20 22:39:27 cgd Exp $
 #
-#       @(#)run.test    8.8 (Berkeley) 6/16/94
+#       $OpenBSD: run.test,v 1.3 2001/01/29 02:05:41 niklas Exp $
+#       $NetBSD: run.test,v 1.8 1996/05/03 21:57:51 cgd Exp $
+#       @(#)run.test    8.10 (Berkeley) 7/26/94
 #
 
 # db regression tests
 main()
 {
 
-DICT=/usr/share/dict/web2
-PROG=./dbtest
-TMP1=t1
-TMP2=t2
-TMP3=t3
+        PROG=./dbtest
+        TMP1=t1
+        TMP2=t2
+        TMP3=t3
 
+        if [ -f /usr/share/dict/words ]; then
+                DICT=/usr/share/dict/words
+        elif [ -f /usr/dict/words ]; then
+                DICT=/usr/dict/words
+        else
+                echo 'run.test: no dictionary'
+                exit 1
+        fi
+        
         if [ $# -eq 0 ]; then
                 for t in 1 2 3 4 5 6 7 8 9 10 11 12 13 20; do
                         test$t
@@ -345,7 +354,7 @@ test7()
                 for (i = 1; i <= 120; ++i)
                         printf("%05d: input key %d: %s\n", i, i, $0);
                 printf("%05d: input key %d: %s\n", 120, 120, $0);
-                printf("get failed, no such key\n");
+                printf("seq failed, no such key\n");
                 printf("%05d: input key %d: %s\n", 1, 1, $0);
                 printf("%05d: input key %d: %s\n", 2, 2, $0);
                 exit;
@@ -364,10 +373,10 @@ test7()
                         for (i = 1; i <= 120; ++i)
                                 printf("s\n");
                         printf("fR_CURSOR\ns\nk120\n");
-                        printf("r\nk120\n");
+                        printf("r\n");
                         printf("fR_NEXT\ns\n");
                         printf("fR_CURSOR\ns\nk1\n");
-                        printf("r\nk1\n");
+                        printf("r\n");
                         printf("fR_FIRST\ns\n");
                 }' > $TMP2
                 $PROG -o $TMP3 recno $TMP2
@@ -397,8 +406,6 @@ test8()
                                 printf("e\t%d of 10             \n", i);
                         printf("r\nkkey1\nr\nkkey2\n");
                 }
-                printf("e\n");
-                printf("eend of test8 run\n");
         }' > $TMP1
         $PROG btree $TMP1
 #       $PROG hash $TMP1
@@ -459,7 +466,7 @@ test10()
                         printf("p\nk%d\nd%s\n", ++i, $0);
                 }
                 END {
-                        printf("fR_CURSOR\nr\nk1\n");
+                        printf("fR_CURSOR\nr\n");
                         printf("eR_CURSOR SHOULD HAVE FAILED\n");
                 }' > $TMP2
                 $PROG -o $TMP3 $type $TMP2 > /dev/null 2>&1
@@ -573,7 +580,8 @@ test13()
                                 echo g
                                 echo k$i
                         done > $TMP2
-                        $PROG -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
+                        $PROG -s \
+                            -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
                         if (cmp -s $TMP1 $TMP3) ; then :
                         else
                                 echo "test13: $type/$order get failed"
diff --git a/src/regress/lib/libc/dirname/Makefile b/src/regress/lib/libc/dirname/Makefile
new file mode 100644
index 0000000000..fc152df954
--- /dev/null
+++ b/src/regress/lib/libc/dirname/Makefile
@@ -0,0 +1,3 @@
+PROG=dirname_test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/dirname/dirname_test.c b/src/regress/lib/libc/dirname/dirname_test.c
new file mode 100644
index 0000000000..add76980cf
--- /dev/null
+++ b/src/regress/lib/libc/dirname/dirname_test.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2007 Bret S. Lambert <blambert@gsipt.net>
+ *
+ * Public domain.
+ */
+
+#include <sys/param.h>
+
+#include <libgen.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+int
+main(void)
+{
+        char path[2 * MAXPATHLEN];
+        char dname[128];
+        const char *dir = "junk";
+        const char *fname = "/file.name.ext";
+        char *str;
+        int i;
+
+        /* Test normal functioning */
+        strlcpy(path, "/", sizeof(path));
+        strlcpy(dname, "/", sizeof(dname));
+        strlcat(path, dir, sizeof(path)); 
+        strlcat(dname, dir, sizeof(dname)); 
+        strlcat(path, fname, sizeof(path));
+        str = dirname(path);
+        if (strcmp(str, dname) != 0)
+                errx(1, "0: dirname(%s) = %s != %s", path, str, dname);
+
+        /*
+         * There are four states that require special handling:
+         *
+         * 1) path is NULL
+         * 2) path is the empty string
+         * 3) path is composed entirely of slashes
+         * 4) the resulting name is larger than MAXPATHLEN
+         *
+         * The first two cases require that a pointer
+         * to the string "." be returned.
+         *
+         * The third case requires that a pointer
+         * to the string "/" be returned.
+         *
+         * The final case requires that NULL be returned
+         * and errno * be set to ENAMETOOLONG.
+         */
+        /* Case 1 */
+        str = dirname(NULL);
+        if (strcmp(str, ".") != 0)
+                errx(1, "1: dirname(NULL) = %s != .", str);
+
+        /* Case 2 */
+        strlcpy(path, "", sizeof(path));
+        str = dirname(path);
+        if (strcmp(str, ".") != 0)
+                errx(1, "2: dirname(%s) = %s != .", path, str);
+
+        /* Case 3 */
+        for (i = 0; i < MAXPATHLEN - 1; i++)
+                strlcat(path, "/", sizeof(path));       /* path cleared above */
+        str = dirname(path);
+        if (strcmp(str, "/") != 0)
+                errx(1, "3: dirname(%s) = %s != /", path, str);
+
+        /* Case 4 */
+        strlcpy(path, "/", sizeof(path));               /* reset path */
+        for (i = 0; i <= MAXPATHLEN; i += strlen(dir))
+                strlcat(path, dir, sizeof(path));
+        strlcat(path, fname, sizeof(path));
+        str = dirname(path);
+        if (str != NULL)
+                errx(1, "4: dirname(%s) = %s != NULL", path, str);
+        if (errno != ENAMETOOLONG)
+                errx(1, "4: dirname(%s) sets errno to %d", path, errno);
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/fnmatch/Makefile b/src/regress/lib/libc/fnmatch/Makefile
new file mode 100644
index 0000000000..b2f357105f
--- /dev/null
+++ b/src/regress/lib/libc/fnmatch/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.1 2008/10/01 23:04:58 millert Exp $
+
+PROG=   fnm_test
+
+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..e987010095
--- /dev/null
+++ b/src/regress/lib/libc/fnmatch/fnm_test.c
@@ -0,0 +1,45 @@
+/*      $OpenBSD: fnm_test.c,v 1.1 2008/10/01 23:04:58 millert Exp $    */
+
+/*
+ * Public domain, 2008, Todd C. Miller <Todd.Miller@courtesan.com>
+ */
+
+#include <err.h>
+#include <fnmatch.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int
+main(int argc, char **argv)
+{
+        FILE *fp = stdin;
+        char pattern[1024], string[1024];
+        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
+         *
+         */
+        for (;;) {
+                got = fscanf(fp, "%s %s 0x%x %d\n", pattern, string, &flags,
+                    &want);
+                if (got == EOF)
+                        break;
+                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++;
+                        }
+                }
+        }
+        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..3c707f8a19
--- /dev/null
+++ b/src/regress/lib/libc/fnmatch/fnm_test.in
@@ -0,0 +1,5 @@
+/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
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/getaddrinfo/Makefile b/src/regress/lib/libc/getaddrinfo/Makefile
new file mode 100644
index 0000000000..4d4978a6a2
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.3 2002/09/02 20:01:43 avsm 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 -u 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..fa4985958f
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/answer
@@ -0,0 +1,104 @@
+== 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 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 ::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 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 ::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 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 7
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 7
+ai3: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 7
+ai4: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.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
+service not supported for ai_socktype
+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
+service not supported for ai_socktype
+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 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 0
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 0
+ai3: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 0
+ai4: 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 (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 24 socktype 3 protocol 0 addrlen 28 host ::1 serv 0
+ai2: flags 0x2 family 2 socktype 3 protocol 0 addrlen 16 host 127.0.0.1 serv 0
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host localhost serv (empty)
+ai1: flags 0x2 family 24 socktype 3 protocol 59 addrlen 28 host ::1 serv 0
+ai2: flags 0x2 family 2 socktype 3 protocol 59 addrlen 16 host 127.0.0.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..059c1aaa1a
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/gaitest.c
@@ -0,0 +1,188 @@
+/*      $OpenBSD: gaitest.c,v 1.5 2004/06/21 21:56:19 itojun 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.
+ */
+
+#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..d09c9846cc
--- /dev/null
+++ b/src/regress/lib/libc/getcap/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.1 2006/03/10 05:28:57 ray Exp $
+
+PROG=           getcaptest
+
+REGRESS_TARGETS=shortcap
+
+shortcap:
+        ./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..6b93edfc38
--- /dev/null
+++ b/src/regress/lib/libc/glob/Makefile
@@ -0,0 +1,13 @@
+#       $OpenBSD: Makefile,v 1.2 2009/02/18 15:17:55 millert Exp $
+
+PROG=   globtest
+
+run-regress-${PROG}:
+        mkdir -p `sed 's@/[^/]*$$@@' ${.CURDIR}/files | sort -u`
+        touch `cat ${.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..f8f93573c6
--- /dev/null
+++ b/src/regress/lib/libc/glob/globtest.c
@@ -0,0 +1,123 @@
+/*      $OpenBSD: globtest.c,v 1.1 2008/10/01 23:04:36 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];
+};
+
+int test_glob(struct gl_entry *);
+
+int
+main(int argc, char **argv)
+{
+        FILE *fp = stdin;
+        char *buf, *cp, *want, *got, *last;
+        const char *errstr;
+        int errors = 0, i, lineno;
+        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
+         * result2
+         * result3
+         * ...
+         *
+         */
+        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 > 0x2000)
+                                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);
+                }
+                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;
+
+        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;
+                free(entry->results[i]);
+        }
+        return (0);
+mismatch:
+        warnx("mismatch for pattern %s, flags 0x%x", entry->pattern,
+            entry->flags);
+        while (i < gl.gl_matchc) {
+                free(entry->results[i++]);
+        }
+        return (0);
+        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..5995fa4b31
--- /dev/null
+++ b/src/regress/lib/libc/glob/globtest.in
@@ -0,0 +1,64 @@
+[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/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
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..2972b54794
--- /dev/null
+++ b/src/regress/lib/libc/hsearch/hsearchtest.c
@@ -0,0 +1,131 @@
+/*      $OpenBSD: hsearchtest.c,v 1.1 2004/06/24 04:33:07 millert 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.
+ */
+
+#ifndef lint
+static const char copyright[] =
+"@(#) Copyright (c) 2001 Christopher G. Demetriou.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static const char rcsid[] = "$OpenBSD: hsearchtest.c,v 1.1 2004/06/24 04:33:07 millert Exp $";
+#endif /* not lint */
+
+#include <search.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define TEST(e) ((e) ? (void)0 : testfail(__FILE__, __LINE__, #e))
+
+static void
+testfail(const char *file, unsigned long line, const char *expression)
+{
+
+        fprintf(stderr, "TEST FAILED: %s: file %s, line %ld\n",
+            expression, file, line);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        ENTRY e, *ep, *ep2;
+        int created_ok;
+        char ch[2];
+        int i;
+
+        created_ok = hcreate(16);
+        TEST(created_ok);
+
+        /* ch[1] should be constant from here on down. */
+        ch[1] = '\0';
+        
+        /* Basic insertions.  Check enough that there'll be collisions. */
+        for (i = 0; i < 26; i++) {
+                ch[0] = 'a' + i;
+                e.key = strdup(ch);     /* ptr to provided key is kept! */
+                TEST(e.key != NULL);
+                e.data = (void *)(long)i;
+                ep = hsearch(e, ENTER);
+                TEST(ep != NULL);
+                TEST(strcmp(ep->key, ch) == 0);
+                TEST((long)ep->data == i);
+        }
+
+        /* e.key should be constant from here on down. */
+        e.key = ch;
+
+        /* Basic lookups. */
+        for (i = 0; i < 26; i++) {
+                ch[0] = 'a' + i;
+                ep = hsearch(e, FIND);
+                TEST(ep != NULL);
+                TEST(strcmp(ep->key, ch) == 0);
+                TEST((long)ep->data == i);
+        }
+
+        /* Check duplicate entry.  Should _not_ overwrite existing data.  */
+        ch[0] = 'a';
+        e.data = (void *)(long)12345;
+        ep = hsearch(e, FIND);
+        TEST(ep != NULL);
+        TEST(strcmp(ep->key, ch) == 0);
+        TEST((long)ep->data == 0);
+
+        /* Check for something that's not there. */
+        ch[0] = 'A';
+        ep = hsearch(e, FIND);
+        TEST(ep == NULL);
+
+        /* Check two at once. */
+        ch[0] = 'a';
+        ep = hsearch(e, FIND);
+        ch[0] = 'b';
+        ep2 = hsearch(e, FIND);
+        TEST(ep != NULL);
+        TEST(strcmp(ep->key, "a") == 0 && (long)ep->data == 0);
+        TEST(ep2 != NULL);
+        TEST(strcmp(ep2->key, "b") == 0 && (long)ep2->data == 1);
+
+        hdestroy();
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/ieeefp/Makefile b/src/regress/lib/libc/ieeefp/Makefile
index 4e2e517b03..89ff51a2e7 100644
--- a/src/regress/lib/libc/ieeefp/Makefile
+++ b/src/regress/lib/libc/ieeefp/Makefile
@@ -1,12 +1,7 @@
-#       $NetBSD: Makefile,v 1.4 1995/10/03 21:59:36 phil Exp $
+#       $OpenBSD: Makefile,v 1.6 2004/01/15 18:53:23 miod Exp $
+#       $NetBSD: Makefile,v 1.5 1996/04/09 16:54:18 phil Exp $
 
-.if ${MACHINE} == "pc532"
-SUBDIR+= round
-.else
-SUBDIR+= except round
-.endif
-
-regress: _SUBDIRUSE
+SUBDIR+= except inf infinity round
 
 install:
 
diff --git a/src/regress/lib/libc/ieeefp/except/Makefile b/src/regress/lib/libc/ieeefp/except/Makefile
index 91f24f15f6..205331548f 100644
--- a/src/regress/lib/libc/ieeefp/except/Makefile
+++ b/src/regress/lib/libc/ieeefp/except/Makefile
@@ -1,12 +1,19 @@
-#       $NetBSD: Makefile,v 1.1 1995/04/26 00:27:25 jtc Exp $
+#       $OpenBSD: Makefile,v 1.5 2004/07/22 19:29:42 kettenis Exp $
 
-PROG=   except
-SRCS=   except.c
-NOMAN=
+PROG=except
 
-install:
+REGRESS_TARGETS+= fltdiv fltinv fltovf fltund
 
-regress: ${PROG}
-        ./${PROG}
+fltdiv: ${PROG}
+        ./${PROG} fltdiv
 
-.include <bsd.prog.mk>
+fltinv: ${PROG}
+        ./${PROG} fltinv
+
+fltovf: ${PROG}
+        ./${PROG} fltovf
+
+fltund: ${PROG}
+        ./${PROG} fltund
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/except/except.c b/src/regress/lib/libc/ieeefp/except/except.c
index 0ffdcdd468..0f25cadefc 100644
--- a/src/regress/lib/libc/ieeefp/except/except.c
+++ b/src/regress/lib/libc/ieeefp/except/except.c
@@ -1,21 +1,47 @@
+/*      $OpenBSD: except.c,v 1.11 2007/10/22 21:07:10 miod Exp $        */
+
+#include <sys/types.h>
+#include <unistd.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <signal.h>
 #include <assert.h>
 #include <ieeefp.h>
 #include <float.h>
+#include <err.h>
 
-void sigfpe();
-volatile sig_atomic_t signal_cought;
+volatile sig_atomic_t signal_status;
 
-static volatile const double one  = 1.0;
-static volatile const double zero = 0.0;
-static volatile const double huge = DBL_MAX;
-static volatile const double tiny = DBL_MIN;
+volatile const double one  = 1.0;
+volatile const double zero = 0.0;
+volatile const double huge = DBL_MAX;
+volatile const double tiny = DBL_MIN;
 
-main()
+void
+sigfpe(int sig, siginfo_t *si, void *v)
 {
+        char buf[132];
+
+        if (si) {
+                snprintf(buf, sizeof(buf), "sigfpe: addr=%p, code=%d\n",
+                    si->si_addr, si->si_code);
+                write(1, buf, strlen(buf));
+        }
+        _exit(signal_status);
+}
+
+
+int
+main(int argc, char *argv[])
+{
+        struct sigaction sa;
         volatile double x;
 
+        if (argc != 2) {
+                fprintf(stderr, "usage: %s condition\n", argv[0]);
+                exit(1);
+        }
+
         /*
          * check to make sure that all exceptions are masked and 
          * that the accumulated exception status is clear.
@@ -23,65 +49,61 @@ main()
         assert(fpgetmask() == 0);
         assert(fpgetsticky() == 0);
 
-        /* set up signal handler */
-        signal (SIGFPE, sigfpe);
-        signal_cought = 0;
-
-        /* trip divide by zero */
-        x = one / zero;
-        assert (fpgetsticky() & FP_X_DZ);
-        assert (signal_cought == 0);
-        fpsetsticky(0);
-
-        /* trip invalid operation */
-        x = zero / zero;
-        assert (fpgetsticky() & FP_X_INV);
-        assert (signal_cought == 0);
-        fpsetsticky(0);
-
-        /* trip overflow */
-        x = huge * huge;
-        assert (fpgetsticky() & FP_X_OFL);
-        assert (signal_cought == 0);
-        fpsetsticky(0);
-
-        /* trip underflow */
-        x = tiny * tiny;
-        assert (fpgetsticky() & FP_X_UFL);
-        assert (signal_cought == 0);
-        fpsetsticky(0);
-
-#if 0
-        /* unmask and then trip divide by zero */
-        fpsetmask(FP_X_DZ);
-        x = one / zero;
-        assert (signal_cought == 1);
-        signal_cought = 0;
-
-        /* unmask and then trip invalid operation */
-        fpsetmask(FP_X_INV);
-        x = zero / zero;
-        assert (signal_cought == 1);
-        signal_cought = 0;
-
-        /* unmask and then trip overflow */
-        fpsetmask(FP_X_OFL);
-        x = huge * huge;
-        assert (signal_cought == 1);
-        signal_cought = 0;
-
-        /* unmask and then trip underflow */
-        fpsetmask(FP_X_UFL);
-        x = tiny * tiny;
-        assert (signal_cought == 1);
-        signal_cought = 0;
-#endif
-
-        exit(0);
-}
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_sigaction = sigfpe;
+        sa.sa_flags = SA_SIGINFO;
+        sigaction(SIGFPE, &sa, NULL);
+        signal_status = 1;
 
-void
-sigfpe()
-{
-        signal_cought = 1;
+        if (strcmp(argv[1], "fltdiv") == 0) {
+                /* trip divide by zero */
+                x = one / zero;
+                assert(fpgetsticky() & FP_X_DZ);
+                fpsetsticky(0);
+
+                /* and now unmask to get a signal */
+                signal_status = 0;
+                fpsetmask(FP_X_DZ);
+                x = one / zero;
+        } else if (strcmp(argv[1], "fltinv") == 0) {
+                /* trip invalid operation */
+                x = zero / zero;
+                assert(fpgetsticky() & FP_X_INV);
+                fpsetsticky(0);
+
+                /* and now unmask to get a signal */
+                signal_status = 0;
+                fpsetmask(FP_X_INV);
+                x = zero / zero;
+        } else if (strcmp(argv[1], "fltovf") == 0) {
+                /* trip overflow */
+                x = huge * huge;
+                assert(fpgetsticky() & FP_X_OFL);
+                fpsetsticky(0);
+
+                /* and now unmask to get a signal */
+                signal_status = 0;
+                fpsetmask(FP_X_OFL);
+                x = huge * huge;
+        } else if (strcmp(argv[1], "fltund") == 0) {
+                /* trip underflow */
+                x = tiny * tiny;
+                assert(fpgetsticky() & FP_X_UFL);
+                fpsetsticky(0);
+
+                /* and now unmask to get a signal */
+                signal_status = 0;
+                fpsetmask(FP_X_UFL);
+                x = tiny * tiny;
+        } else {
+                errx(1, "unrecognized condition %s", argv[1]);
+        }
+
+        /*
+         * attempt to trigger the exception on machines where
+         * floating-point exceptions are deferred.
+         */
+        x = one * one;
+
+        errx(1, "signal wasn't caught");
 }
diff --git a/src/regress/lib/libc/ieeefp/inf/Makefile b/src/regress/lib/libc/ieeefp/inf/Makefile
new file mode 100644
index 0000000000..b9a50e0ce6
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/inf/Makefile
@@ -0,0 +1,9 @@
+#       $OpenBSD: Makefile,v 1.1 2002/02/16 17:22:16 pvalchev Exp $
+
+PROG=   inf
+SRCS=   inf.c
+
+LDADD+= -lm
+DPADD+= ${LIBM}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/inf/inf.c b/src/regress/lib/libc/ieeefp/inf/inf.c
new file mode 100644
index 0000000000..a1956145a6
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/inf/inf.c
@@ -0,0 +1,16 @@
+/*      $OpenBSD: inf.c,v 1.3 2003/07/31 21:48:03 deraadt Exp $ */
+
+/*
+ * Peter Valchev <pvalchev@openbsd.org> Public Domain, 2002.
+ */
+
+#include <math.h>
+
+int
+main(int argc, char *argv[])
+{
+        if (isinf(HUGE_VAL))
+                return 0;
+
+        return 1;
+}
diff --git a/src/regress/lib/libc/ieeefp/infinity/Makefile b/src/regress/lib/libc/ieeefp/infinity/Makefile
new file mode 100644
index 0000000000..ac102d8a63
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/infinity/Makefile
@@ -0,0 +1,22 @@
+#       $OpenBSD: Makefile,v 1.2 2004/01/16 19:34:37 miod Exp $
+
+PROG=   infinity
+
+DPADD+= ${LIBM}
+LDADD+= -lm
+
+REGRESS_TARGETS+= add mult neg pumpkin
+
+add: ${PROG}
+        ./${PROG} -a
+
+mult: ${PROG}
+        ./${PROG} -m
+
+neg: ${PROG}
+        ./${PROG} -n
+
+pumpkin: ${PROG}
+        ./${PROG} -p
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/infinity/infinity.c b/src/regress/lib/libc/ieeefp/infinity/infinity.c
new file mode 100644
index 0000000000..3b1b71ec90
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/infinity/infinity.c
@@ -0,0 +1,77 @@
+/*      $OpenBSD: infinity.c,v 1.2 2004/01/16 19:34:37 miod Exp $       */
+/*
+ * Written by Miodrag Vallat, 2004 - Public Domain
+ * Inspired from Perl's t/op/arith test #134
+ */
+
+#include <math.h>
+#include <signal.h>
+#include <unistd.h>
+
+void
+sigfpe(int signum)
+{
+        /* looks like we don't handle fp overflow correctly... */
+        _exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        int opt;
+        double d, two;
+        int i;
+        char method = 'a';
+
+        while ((opt = getopt(argc, argv, "amnp")) != -1)
+                method = (char)opt;
+
+        signal(SIGFPE, sigfpe);
+
+        switch (method) {
+        case 'a':
+                /* try to produce +Inf through addition */
+                d = 1.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d + d;
+                }
+                /* result should be _positive_ infinity */
+                if (!isinf(d) || copysign(1.0, d) < 0.0)
+                        return (1);
+                break;
+        case 'm':
+                /* try to produce +Inf through multiplication */
+                d = 1.0;
+                two = 2.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d * two;
+                }
+                /* result should be _positive_ infinity */
+                if (!isinf(d) || copysign(1.0, d) < 0.0)
+                        return (1);
+                break;
+        case 'n':
+                /* try to produce -Inf through subtraction */
+                d = -1.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d + d;
+                }
+                /* result should be _negative_ infinity */
+                if (!isinf(d) || copysign(1.0, d) > 0.0)
+                        return (1);
+                break;
+        case 'p':
+                /* try to produce -Inf through multiplication */
+                d = -1.0;
+                two = 2.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d * two;
+                }
+                /* result should be _negative_ infinity */
+                if (!isinf(d) || copysign(1.0, d) > 0.0)
+                        return (1);
+                break;
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/ieeefp/round/Makefile b/src/regress/lib/libc/ieeefp/round/Makefile
index 571133436c..9ea6dd8c39 100644
--- a/src/regress/lib/libc/ieeefp/round/Makefile
+++ b/src/regress/lib/libc/ieeefp/round/Makefile
@@ -1,12 +1,5 @@
-#       $NetBSD: Makefile,v 1.1 1995/04/26 00:27:27 jtc Exp $
+#       $OpenBSD: Makefile,v 1.4 2002/02/18 11:25:34 art Exp $
 
 PROG=   round
-SRCS=   round.c
-NOMAN=
 
-install:
-
-regress: ${PROG}
-        ./${PROG}
-
-.include <bsd.prog.mk>
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/round/round.c b/src/regress/lib/libc/ieeefp/round/round.c
index b9fcd9771e..807941ea56 100644
--- a/src/regress/lib/libc/ieeefp/round/round.c
+++ b/src/regress/lib/libc/ieeefp/round/round.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: round.c,v 1.3 2003/07/31 21:48:03 deraadt Exp $       */
 /*      $NetBSD: round.c,v 1.1 1995/04/26 00:27:28 jtc Exp $    */
 
 /*
@@ -11,7 +12,7 @@
 #include <float.h>
 
 int
-main()
+main(int argc, char *argv[])
 {
         /*
          * This test would be better if it actually performed some
diff --git a/src/regress/lib/libc/locale/Makefile b/src/regress/lib/libc/locale/Makefile
new file mode 100644
index 0000000000..c182172ba2
--- /dev/null
+++ b/src/regress/lib/libc/locale/Makefile
@@ -0,0 +1,7 @@
+# $OpenBSD: Makefile,v 1.1 2005/08/11 21:57:02 espie Exp $
+
+SUBDIR+= check_isw
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/locale/check_isw/Makefile b/src/regress/lib/libc/locale/check_isw/Makefile
new file mode 100644
index 0000000000..0885968fd1
--- /dev/null
+++ b/src/regress/lib/libc/locale/check_isw/Makefile
@@ -0,0 +1,9 @@
+#       $OpenBSD: Makefile,v 1.1 2005/08/11 21:57:02 espie Exp $
+
+NOMAN=
+PROG=check_isw
+
+run-regress-check_isw: ${PROG}
+        ./${PROG} >/dev/null
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/locale/check_isw/check_isw.c b/src/regress/lib/libc/locale/check_isw/check_isw.c
new file mode 100644
index 0000000000..9386267f61
--- /dev/null
+++ b/src/regress/lib/libc/locale/check_isw/check_isw.c
@@ -0,0 +1,147 @@
+/* $OpenBSD: check_isw.c,v 1.1 2005/08/11 21:57:02 espie Exp $ */
+/*
+ * Copyright (c) 2005 Marc Espie <espie@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* This checks consistency of the isw* functions with the default <ctype>
+ * functions.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <wchar.h>
+#include <wctype.h>
+
+int bad = 0;
+
+void
+check_bool(int v1, int v2, char msg)
+{
+        if (!v1 != !v2) {
+                printf("%c", msg);
+                bad++;
+        }
+}
+
+void 
+check_value(int v1, int v2, char msg)
+{
+        if (v1 != v2) {
+                printf("%c", msg);
+                bad++;
+        }
+}
+
+void
+test1()
+{
+        int i;
+
+        for (i = 0; i < 256; i++) {
+                printf(" %02x: ", i);
+                check_bool(isalnum(i), iswalnum(i), '1');
+                check_bool(isalpha(i), iswalpha(i), '2');
+                check_bool(isblank(i), iswblank(i), '3');
+                check_bool(iscntrl(i), iswcntrl(i), '4');
+                check_bool(isdigit(i), iswdigit(i), '5');
+                check_bool(isgraph(i), iswgraph(i), '6');
+                check_bool(islower(i), iswlower(i), '6');
+                check_bool(isprint(i), iswprint(i), '7');
+                check_bool(ispunct(i), iswpunct(i), '8');
+                check_bool(isspace(i), iswspace(i), '9');
+                check_bool(isupper(i), iswupper(i), 'a');
+                check_bool(isxdigit(i), iswxdigit(i), 'b');
+                check_value(tolower(i), towlower(i), 'c');
+                check_value(toupper(i), towupper(i), 'd');
+                if (i % 8 == 7)
+                        printf("\n");
+        }
+        printf("%\n");
+}
+
+void
+test2()
+{
+        unsigned char *s;
+        unsigned char *buf;
+        int i, j;
+        size_t n;
+        wchar_t c, d;
+        mbstate_t state;
+
+        s = malloc(256);
+        if (!s) {
+                bad++;
+                return;
+        }
+        buf = malloc(MB_CUR_MAX);
+        if (!buf) {
+                bad++;
+                free(s);
+                return;
+        }
+        for (i = 0; i < 256; i++)
+                s[i] = i+1;
+
+        j = 0;
+        mbrtowc(NULL, NULL, 1, &state);
+        printf(" %02x: ", 0);
+
+        while ((n = mbrtowc(&c, s+j, 256-j, &state)) == 1) {
+                printf(" %02x: ", s[j]);
+                check_bool(isalnum(s[j]), iswalnum(c), '1');
+                check_bool(isalpha(s[j]), iswalpha(c), '2');
+                check_bool(isblank(s[j]), iswblank(c), '3');
+                check_bool(iscntrl(s[j]), iswcntrl(c), '4');
+                check_bool(isdigit(s[j]), iswdigit(c), '5');
+                check_bool(isgraph(s[j]), iswgraph(c), '6');
+                check_bool(islower(s[j]), iswlower(c), '6');
+                check_bool(isprint(s[j]), iswprint(c), '7');
+                check_bool(ispunct(s[j]), iswpunct(c), '8');
+                check_bool(isspace(s[j]), iswspace(c), '9');
+                check_bool(isupper(s[j]), iswupper(c), 'a');
+                check_bool(isxdigit(s[j]), iswxdigit(c), 'b');
+                d = towlower(c);
+                if (wctomb(buf, d) == 1) {      
+                        check_value(tolower(s[j]), buf[0], 'c');
+                } else {
+                        bad++;
+                }
+                d = towupper(c);
+                if (wctomb(buf, d) == 1) {      
+                        check_value(toupper(s[j]), buf[0], 'c');
+                } else {
+                        bad++;
+                }
+                if (s[j] % 8 == 7)
+                        printf("\n");
+                j++;
+        }
+        if (n != 0 || j != 255) {
+                bad++;
+        }
+        free(s);
+        free(buf);
+}
+
+
+int
+main()
+{
+        test1();
+        test2();
+        return bad !=0;
+}
diff --git a/src/regress/lib/libc/longjmp/Makefile b/src/regress/lib/libc/longjmp/Makefile
new file mode 100644
index 0000000000..825e0f86d9
--- /dev/null
+++ b/src/regress/lib/libc/longjmp/Makefile
@@ -0,0 +1,13 @@
+#       $OpenBSD: Makefile,v 1.4 2002/09/02 20:01:43 avsm Exp $
+PROG=   longjmp
+
+do-longjmp: ${PROG}
+        ./longjmp
+
+do-_longjmp: ${PROG}
+        ./longjmp -_
+
+REGRESS_TARGETS=do-longjmp do-_longjmp
+.PHONY: ${REGRESS_TARGETS}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/longjmp/longjmp.c b/src/regress/lib/libc/longjmp/longjmp.c
new file mode 100644
index 0000000000..7dea5bd97c
--- /dev/null
+++ b/src/regress/lib/libc/longjmp/longjmp.c
@@ -0,0 +1,71 @@
+/*      $OpenBSD: longjmp.c,v 1.4 2002/02/18 11:27:45 art Exp $ */
+/*
+ *      Artur Grabowski <art@openbsd.org>, 2002 Public Domain.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <setjmp.h>
+#include <err.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+
+jmp_buf buf;
+
+/*
+ * When longjmp is passed the incorrect arg (0), it should translate it into
+ * something better.
+ *
+ * The rlimit is here in case we start spinning.
+ */
+int
+main(int argc, char **argv)
+{
+        struct rlimit rl;
+        volatile int i, expect;
+        int (*sj)(jmp_buf);
+        void (*lj)(jmp_buf, int);
+        int ch;
+        extern char *__progname;
+
+        sj = setjmp;
+        lj = longjmp;
+
+        while ((ch = getopt(argc, argv, "_")) != -1) {
+                switch (ch) {
+                case '_':
+                        sj = _setjmp;
+                        lj = _longjmp;
+                        break;
+                default:
+                        fprintf(stderr, "Usage: %s [-_]\n", __progname);
+                        exit(1);
+                }
+        }
+
+        rl.rlim_cur = 2;
+        rl.rlim_max = 2;
+        if (setrlimit(RLIMIT_CPU, &rl) < 0)
+                err(1, "setrlimit");
+
+        expect = 0;
+        i = (*sj)(buf);
+        if (i == 0 && expect != 0)
+                errx(1, "setjmp returns 0 on longjmp(.., 0)");
+        if (expect == 0) {
+                expect = -1;
+                (*lj)(buf, 0);
+        }
+
+        expect = 0;
+        i = (*sj)(buf);
+        if (i != expect)
+                errx(1, "bad return from setjmp %d/%d", expect, i);
+        if (expect < 1000)
+                (*lj)(buf, expect += 2);
+
+        return 0;
+}
diff --git a/src/regress/lib/libc/malloc/Makefile b/src/regress/lib/libc/malloc/Makefile
new file mode 100644
index 0000000000..7c919d1bc2
--- /dev/null
+++ b/src/regress/lib/libc/malloc/Makefile
@@ -0,0 +1,7 @@
+#       $OpenBSD: Makefile,v 1.5 2006/04/18 19:04:39 otto Exp $
+
+SUBDIR+= malloc0test malloc_errno malloc_ulimit1 malloc_ulimit2
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/malloc/malloc0test/Makefile b/src/regress/lib/libc/malloc/malloc0test/Makefile
new file mode 100644
index 0000000000..8ed8163a79
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc0test/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/07/15 10:09:37 otto Exp $
+
+PROG=   malloc0test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc0test/malloc0test.c b/src/regress/lib/libc/malloc/malloc0test/malloc0test.c
new file mode 100644
index 0000000000..06ff0996ee
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc0test/malloc0test.c
@@ -0,0 +1,120 @@
+/*      $OpenBSD: malloc0test.c,v 1.5 2008/04/13 00:22:17 djm Exp $     */
+/*
+ * Public domain.  2001, Theo de Raadt
+ */
+#include <sys/types.h>
+#include <sys/signal.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include <limits.h>
+#include <errno.h>
+
+volatile sig_atomic_t got;
+jmp_buf jmp;
+
+static void
+catch(int signo)
+{
+        got++;
+        longjmp(jmp, 1);
+}
+
+static int
+test(char *p, int size)
+{
+        signal(SIGSEGV, catch);
+        got = 0;
+        if (setjmp(jmp) == 0)
+                *p = 0;
+        if (setjmp(jmp) == 0)
+                *(p+size-1) = 0;
+        return (got);
+}
+
+char *prot_table[] = {
+        "unprotected",
+        "fuckup",
+        "protected"
+};
+
+#define SIZE    10
+
+/*
+ * Do random memory allocations.
+ *
+ * For each one, ensure that it is at least 16 bytes in size (that
+ * being what our current malloc returns for the minsize of an
+ * object, alignment wise);
+ *
+ * For zero-byte allocations, check that they are still aligned.
+ *
+ * For each object, ensure that they are correctly protected or not
+ * protected.
+ *
+ * Does not regress test malloc + free combinations ... it should.
+ */
+int
+main(int argc, char *argv[])
+{
+        caddr_t blob;
+        int size, tsize;
+        int prot;
+        int rval = 0, fuckup = 0;
+        long limit = 200000, count;
+        int ch, silent = 0;
+        char *ep;
+        extern char *__progname;
+
+        while ((ch = getopt(argc, argv, "sn:")) != -1) {
+                switch (ch) {
+                case 's':
+                        silent = 1;
+                        break;
+                case 'n':
+                        errno = 0;
+                        limit = strtol(optarg, &ep, 10);
+                        if (optarg[0] == '\0' || *ep != '\0' ||
+                            (errno == ERANGE &&
+                             (limit == LONG_MAX || limit == LONG_MIN)))
+                                goto usage;
+                        break;
+                default:
+usage:
+                        fprintf(stderr, "Usage: %s [-s][-n <count>]\n",
+                            __progname);
+                        exit(1);
+                }
+        }
+
+        if (limit == 0)
+                limit = LONG_MAX;
+
+        for (count = 0; count < limit; count++) {
+                size = arc4random_uniform(SIZE);
+                blob = malloc(size);
+                if (blob == NULL) {
+                        fprintf(stderr, "success: out of memory\n");
+                        exit(rval);
+                }
+
+                tsize = size == 0 ? 16 : size;
+                fuckup = 0;
+                prot = test(blob, tsize);
+
+                if (size == 0 && prot < 2)
+                        fuckup = 1;
+
+                if (fuckup) {
+                        printf("%8p %6d %20s %10s\n", blob, size,
+                            prot_table[prot], fuckup ? "fuckup" : "");
+                        rval = 1;
+                }
+
+                if (!silent && count % 100000 == 0 && count != 0)
+                        fprintf(stderr, "count = %ld\n", count);
+        }
+
+        return rval;
+}
diff --git a/src/regress/lib/libc/malloc/malloc_errno/Makefile b/src/regress/lib/libc/malloc/malloc_errno/Makefile
new file mode 100644
index 0000000000..73ebe37491
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_errno/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/07/15 10:06:31 otto Exp $
+
+PROG=   malloc_errno
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c b/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c
new file mode 100644
index 0000000000..896ea3c900
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c
@@ -0,0 +1,46 @@
+/*      $OpenBSD: malloc_errno.c,v 1.4 2003/12/25 18:49:57 miod Exp $   */
+/*
+ * Public domain.  2003, Otto Moerbeek
+ */
+#include <err.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static void
+testerrno(size_t sz)
+{
+        void *p;
+
+        errno = -1;
+        p = malloc(sz);
+
+        if (p == NULL && errno != ENOMEM)
+                errx(1, "fail: %lx %p %d", (unsigned long)sz, p, errno);
+
+        /* if alloc succeeded, test if errno did not change */
+        if (p != NULL && errno != -1) 
+                errx(1, "fail: %lx %p %d", (unsigned long)sz, p, errno);
+
+        free(p);
+}
+
+/*
+ * Provide some (silly) arguments to malloc(), and check if ERRNO is set
+ * correctly.
+ */
+int
+main(int argc, char *argv[])
+{
+        size_t i;
+
+        testerrno(1);
+        testerrno(100000);
+        testerrno(-1);
+        testerrno(-1000);
+        testerrno(-10000);
+        testerrno(-10000000);
+        for (i = 0; i < 0x10; i++)
+                testerrno(i * 0x10000000);
+        return 0;
+}
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile b/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile
new file mode 100644
index 0000000000..46ced27a98
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/04/18 19:03:30 otto Exp $
+
+PROG=   malloc_ulimit1
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c b/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c
new file mode 100644
index 0000000000..99e805e8e1
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c
@@ -0,0 +1,44 @@
+/*      $OpenBSD: malloc_ulimit1.c,v 1.2 2006/05/16 05:47:13 otto Exp $ */
+
+/* Public Domain, 2006, Otto Moerbeek <otto@drijf.net> */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <err.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/*
+ * This code tries to trigger the case present in -current as of April
+ * 2006) where the allocation of the region itself succeeds, but the
+ * page dir entry pages fails.
+ * This in turn trips a "hole in directories" error.
+ * Having a large (512M) ulimit -m helps a lot in triggering the 
+ * problem. Note that you may need to run this test multiple times to
+ * see the error.
+*/
+
+#define STARTI  1300
+#define FACTOR  1024
+
+main()
+{
+        struct rlimit lim;
+        size_t sz;
+        int i;
+        void *p;
+
+        if (getrlimit(RLIMIT_DATA, &lim) == -1)
+                err(1, "getrlimit");
+
+        sz = lim.rlim_cur / FACTOR;
+
+        for (i = STARTI; i >= 0; i--) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                free(p);
+                free(malloc(4096));
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile b/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile
new file mode 100644
index 0000000000..bc83666415
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/04/18 19:04:03 otto Exp $
+
+PROG=   malloc_ulimit2
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c b/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c
new file mode 100644
index 0000000000..ca8e8f438a
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c
@@ -0,0 +1,42 @@
+/*      $OpenBSD: malloc_ulimit2.c,v 1.2 2006/05/16 05:47:13 otto Exp $ */
+
+/* Public Domain, 2006, Otto Moerbeek <otto@drijf.net> */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <err.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define FACTOR  1024
+
+main()
+{
+        struct rlimit lim;
+        size_t sz;
+        int i;
+        void *p;
+
+        if (getrlimit(RLIMIT_DATA, &lim) == -1)
+                err(1, "getrlimit");
+
+        sz = lim.rlim_cur / FACTOR;
+
+        for (i = 0; ; i++) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                if (p != NULL) {
+                        free(p);
+                        break;
+                }
+        }
+        i += 10;
+        for (; i >= 0; i--) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                free(p);
+                free(malloc(4096));
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/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..0082c1bd1b
--- /dev/null
+++ b/src/regress/lib/libc/netdb/netdb.c
@@ -0,0 +1,182 @@
+/*      $OpenBSD: netdb.c,v 1.1 2004/10/25 15:10:36 otto Exp $  */
+
+/*
+ * Public domain, 2004, Otto Moerbeek <otto@drijf.net>
+ */
+
+#include <err.h>
+#include <netdb.h>
+#include <stdarg.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/popen/Makefile b/src/regress/lib/libc/popen/Makefile
new file mode 100644
index 0000000000..25b8668a7a
--- /dev/null
+++ b/src/regress/lib/libc/popen/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2002/02/16 01:55:09 art Exp $
+
+PROG=popen
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/popen/popen.c b/src/regress/lib/libc/popen/popen.c
new file mode 100644
index 0000000000..916cb71b03
--- /dev/null
+++ b/src/regress/lib/libc/popen/popen.c
@@ -0,0 +1,98 @@
+/*      $NetBSD: popen.c,v 1.1 1999/09/30 09:23:23 tron Exp $   */
+
+/*-
+ * Copyright (c) 1999 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Matthias Scheler.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+
+#include <err.h>
+#include <errno.h>
+#include <paths.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+
+#define _PATH_CAT       "/bin/cat"
+#define BUFSIZE         (640*1024)
+                        /* 640KB ought to be enough for everyone. */
+#define DATAFILE        "popen.data"
+
+int
+main(int argc, char **argv)
+{
+        char *buffer, command[MAXPATHLEN];
+        int index, in;
+        FILE *pipe;
+
+        if ((buffer = malloc(BUFSIZE*sizeof(char))) == NULL)
+            err(1, NULL);
+
+        for (index=0; index<BUFSIZE; index++)
+            buffer[index]=arc4random();
+
+        (void)snprintf(command, sizeof(command), "%s >%s",
+                       _PATH_CAT, DATAFILE);
+        if ((pipe = popen(command, "w")) == NULL)
+            err(1, "popen write");
+
+        if (fwrite(buffer, sizeof(char), BUFSIZE, pipe) != BUFSIZE)
+            err(1, "write");
+
+        if (pclose(pipe) == -1)
+            err(1, "pclose");
+
+        (void)snprintf(command, sizeof(command), "%s %s",
+                       _PATH_CAT, DATAFILE);
+        if ((pipe = popen(command, "r")) == NULL)
+            err(1, "popen read");
+
+        index = 0;
+        while ((in = fgetc(pipe)) != EOF)
+            if (index == BUFSIZE) {
+                errno = EFBIG;
+                err(1, "read");
+            }
+            else
+                if ((char)in != buffer[index++]) {
+                    errno = EINVAL;
+                    err(1, "read");
+                }
+
+        if (index < BUFSIZE) {
+            errno = EIO;
+            err(1, "read");
+        }
+
+        if (pclose(pipe) == -1)
+            err(1, "pclose");
+
+        (void)unlink(DATAFILE);
+        return 0;
+}
diff --git a/src/regress/lib/libc/printf/Makefile b/src/regress/lib/libc/printf/Makefile
new file mode 100644
index 0000000000..c2e2732d6e
--- /dev/null
+++ b/src/regress/lib/libc/printf/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2008/09/07 20:36:10 martynas Exp $
+
+PROG=   fp
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/printf/fp.c b/src/regress/lib/libc/printf/fp.c
new file mode 100644
index 0000000000..6ed52fdb49
--- /dev/null
+++ b/src/regress/lib/libc/printf/fp.c
@@ -0,0 +1,217 @@
+/*      $OpenBSD: fp.c,v 1.1 2008/09/07 20:36:10 martynas Exp $ */
+/*-
+ * Copyright (c) 2002, 2005 David Schultz <das@FreeBSD.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Test for printf() floating point formats.
+ */
+
+#include <assert.h>
+#include <err.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define testfmt(result, fmt, ...)       \
+        _testfmt((result), __LINE__, #__VA_ARGS__, fmt, __VA_ARGS__)
+void _testfmt(const char *, int, const char *, const char *, ...);
+void smash_stack(void);
+
+int
+main(int argc, char *argv[])
+{
+        /*
+         * Basic tests of decimal output functionality.
+         */
+        testfmt(" 1.000000E+00", "%13E", 1.0);
+        testfmt("     1.000000", "%13f", 1.0);
+        testfmt("            1", "%13G", 1.0);
+        testfmt(" 1.000000E+00", "%13LE", 1.0L);
+        testfmt("     1.000000", "%13Lf", 1.0L);
+        testfmt("            1", "%13LG", 1.0L);
+
+        testfmt("2.718282", "%.*f", -2, 2.7182818);
+
+        testfmt("1.234568e+06", "%e", 1234567.8);
+        testfmt("1234567.800000", "%f", 1234567.8);
+        testfmt("1.23457E+06", "%G", 1234567.8);
+        testfmt("1.234568e+06", "%Le", 1234567.8L);
+        testfmt("1234567.800000", "%Lf", 1234567.8L);
+        testfmt("1.23457E+06", "%LG", 1234567.8L);
+
+#if (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__)
+        testfmt("123456789.864210", "%Lf", 123456789.8642097531L);
+        testfmt("-1.23457E+08", "%LG", -123456789.8642097531L);
+        testfmt("123456789.8642097531", "%.10Lf", 123456789.8642097531L);
+        testfmt(" 3.141592653589793238e-4000", "%L27.18Le",
+            3.14159265358979323846e-4000L);
+#endif /* (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__) */
+
+        /*
+         * Infinities and NaNs
+         */
+#ifdef NAN
+        testfmt("nan", "%e", NAN);
+        testfmt("NAN", "%F", NAN);
+        testfmt("nan", "%g", NAN);
+        testfmt("NAN", "%LE", (long double)NAN);
+        testfmt("  nan", "%05e", NAN);
+#endif /* NAN */
+
+        testfmt("INF", "%E", HUGE_VAL);
+        testfmt("-inf", "%f", -HUGE_VAL);
+        testfmt("+inf", "%+g", HUGE_VAL);
+        testfmt(" inf", "%4.2Le", HUGE_VALL);
+        testfmt("-inf", "%Lf", -HUGE_VALL);
+        testfmt("  inf", "%05e", HUGE_VAL);
+        testfmt(" -inf", "%05e", -HUGE_VAL);
+
+        /*
+         * Padding
+         */
+        testfmt("0.000000e+00", "%e", 0.0);
+        testfmt("0.000000", "%F", (double)0.0);
+        testfmt("0", "%G", 0.0);
+        testfmt("  0", "%3.0Lg", 0.0L);
+        testfmt("    0", "%5.0f", 0.001);
+
+        /*
+         * Precision specifiers
+         */
+        testfmt("1.0123e+00", "%.4e", 1.0123456789);
+        testfmt("1.0123", "%.4f", 1.0123456789);
+        testfmt("1.012", "%.4g", 1.0123456789);
+        testfmt("1.2346e-02", "%.4e", 0.0123456789);
+        testfmt("0.0123", "%.4f", 0.0123456789);
+        testfmt("0.01235", "%.4g", 0.0123456789);
+
+        /*
+         * Signed conversions
+         */
+        testfmt("+2.500000e-01", "%+e", 0.25);
+        testfmt("+0.000000", "%+F", 0.0);
+        testfmt("-1", "%+g", -1.0);
+
+        testfmt("-1.000000e+00", "% e", -1.0);
+        testfmt("+1.000000", "% +f", 1.0);
+        testfmt(" 1", "% g", 1.0);
+        testfmt(" 0", "% g", 0.0);
+
+        /*
+         * ``Alternate form''
+         */
+        testfmt("1.250e+00", "%#.3e", 1.25);
+        testfmt("123.000000", "%#f", 123.0);
+        testfmt(" 12345.", "%#7.5g", 12345.0);
+        testfmt(" 1.00000", "%#8g", 1.0);
+        testfmt("0.0", "%#.2g", 0.0);
+
+        /*
+         * Padding and decimal point placement
+         */
+        testfmt("03.2E+00", "%08.1E", 3.25);
+        testfmt("003.25", "%06.2F", 3.25);
+        testfmt("0003.25", "%07.4G", 3.25);
+
+        testfmt("3.14159e-05", "%g", 3.14159e-5);
+        testfmt("0.000314159", "%g", 3.14159e-4);
+        testfmt("3.14159e+06", "%g", 3.14159e6);
+        testfmt("314159", "%g", 3.14159e5);
+        testfmt("314159.", "%#g", 3.14159e5);
+
+        testfmt(" 9.000000e+03", "%13e", 9000.0);
+        testfmt(" 9000.000000", "%12f", 9000.0);
+        testfmt(" 9000", "%5g", 9000.0);
+        testfmt(" 900000.", "%#8g", 900000.0);
+        testfmt(" 9e+06", "%6g", 9000000.0);
+        testfmt(" 9.000000e-04", "%13e", 0.0009);
+        testfmt(" 0.000900", "%9f", 0.0009);
+        testfmt(" 0.0009", "%7g", 0.0009);
+        testfmt(" 9e-05", "%6g", 0.00009);
+        testfmt(" 9.00000e-05", "%#12g", 0.00009);
+        testfmt(" 9.e-05", "%#7.1g", 0.00009);
+
+        testfmt(" 0.0", "%4.1f", 0.0);
+        testfmt("90.0", "%4.1f", 90.0);
+        testfmt(" 100", "%4.0f", 100.0);
+        testfmt("9.0e+01", "%4.1e", 90.0);
+        testfmt("1e+02", "%4.0e", 100.0);
+
+        /*
+         * Hexadecimal floating point (%a, %A) tests.  Some of these
+         * are only valid if the implementation converts to hex digits
+         * on nibble boundaries.
+         */
+        testfmt("0x0p+0", "%a", 0x0.0p0);
+        testfmt("0X0.P+0", "%#LA", 0x0.0p0L);
+#ifdef NAN
+        testfmt("inf", "%La", (long double)INFINITY);
+        testfmt("+INF", "%+A", INFINITY);
+        testfmt("nan", "%La", (long double)NAN);
+        testfmt("NAN", "%A", NAN);
+#endif /* NAN */
+
+        testfmt(" 0x1.23p+0", "%10a", 0x1.23p0);
+        testfmt(" 0x1.23p-500", "%12a", 0x1.23p-500);
+        testfmt(" 0x1.2p+40", "%10.1a", 0x1.23p40);
+        testfmt(" 0X1.230000000000000000000000P-4", "%32.24A", 0x1.23p-4);
+        testfmt("0x1p-1074", "%a", 0x1p-1074);
+        testfmt("0x1.2345p-1024", "%a", 0x1.2345p-1024);
+
+        return (0);
+}
+
+void
+smash_stack(void)
+{
+        static uint32_t junk = 0xdeadbeef;
+        uint32_t buf[512];
+        int i;
+
+        for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++)
+                buf[i] = junk;
+}
+
+void
+_testfmt(const char *result, int line, const char *argstr, const char *fmt,...)
+{
+        char s[100];
+        va_list ap;
+
+        va_start(ap, fmt);
+        smash_stack();
+        vsnprintf(s, sizeof(s), fmt, ap);
+        if (strcmp(result, s) != 0) {
+                fprintf(stderr,
+                    "%d: printf(\"%s\", %s) ==> [%s], expected [%s]\n",
+                    line, fmt, argstr, s, result);
+                abort();
+        }
+}
diff --git a/src/regress/lib/libc/regex/Makefile b/src/regress/lib/libc/regex/Makefile
index 93b7bb9052..271debb5d3 100644
--- a/src/regress/lib/libc/regex/Makefile
+++ b/src/regress/lib/libc/regex/Makefile
@@ -1,16 +1,21 @@
+#       $OpenBSD: Makefile,v 1.6 2004/08/13 14:54:12 millert Exp $
 #       $NetBSD: Makefile,v 1.2 1995/02/16 19:38:45 cgd Exp $
 
 PROG=   re
-SRCS=   main.c split.c debug.c
-NOMAN=
+SRCS=   main.c split.c debug.c regcomp.c regerror.c regexec.c regfree.c
+.PATH: ${.CURDIR}/../../../../lib/libc/regex
 
-CFLAGS+= -I${.CURDIR}/../../../../lib/libc/regex
+CFLAGS+= -I${.CURDIR}/../../../../lib/libc/regex -DREDEBUG -DPOSIX_MISTAKE
 
 TESTS=  ${.CURDIR}/tests
 
-regress:
+REGRESS_TARGETS=do-reg do-reg-long do-reg-backref
+
+do-reg: ${PROG}
         ./re < ${TESTS}
+do-reg-long: ${PROG}
         ./re -el < ${TESTS}
+do-reg-backref: ${PROG}
         ./re -er < ${TESTS}
 
-.include <bsd.prog.mk>
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/regex/debug.c b/src/regress/lib/libc/regex/debug.c
index 861f550611..11129e7249 100644
--- a/src/regress/lib/libc/regex/debug.c
+++ b/src/regress/lib/libc/regex/debug.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: debug.c,v 1.4 2003/07/31 21:48:03 deraadt Exp $       */
 /*      $NetBSD: debug.c,v 1.2 1995/04/20 22:39:42 cgd Exp $    */
 
 #include <stdio.h>
@@ -218,7 +219,7 @@ FILE *d;
                         fprintf(d, ">");
                         break;
                 default:
-                        fprintf(d, "!%d(%d)!", OP(*s), opnd);
+                        fprintf(d, "!%ld(%ld)!", (long)OP(*s), (long)opnd);
                         break;
                 }
                 if (!done)
@@ -237,8 +238,8 @@ int ch;
         static char buf[10];
 
         if (isprint(ch) || ch == ' ')
-                sprintf(buf, "%c", ch);
+                snprintf(buf, sizeof buf, "%c", ch);
         else
-                sprintf(buf, "\\%o", ch);
+                snprintf(buf, sizeof buf, "\\%o", ch);
         return(buf);
 }
diff --git a/src/regress/lib/libc/regex/debug.ih b/src/regress/lib/libc/regex/debug.ih
index fb9bac0c75..9eb313af23 100644
--- a/src/regress/lib/libc/regex/debug.ih
+++ b/src/regress/lib/libc/regex/debug.ih
@@ -1,3 +1,4 @@
+/*      $OpenBSD: debug.ih,v 1.3 2002/02/16 21:27:32 millert Exp $      */
 /*      $NetBSD: debug.ih,v 1.2 1995/04/20 22:39:47 cgd Exp $   */
 
 /* ========= begin header generated by ./mkh ========= */
@@ -6,9 +7,9 @@ extern "C" {
 #endif
 
 /* === debug.c === */
-void regprint __P((regex_t *r, FILE *d));
-static void s_print __P((register struct re_guts *g, FILE *d));
-static char *regchar __P((int ch));
+void regprint(regex_t *r, FILE *d);
+static void s_print(register struct re_guts *g, FILE *d);
+static char *regchar(int ch);
 
 #ifdef __cplusplus
 }
diff --git a/src/regress/lib/libc/regex/main.c b/src/regress/lib/libc/regex/main.c
index 8d88a8b9b8..e0ed86f5e8 100644
--- a/src/regress/lib/libc/regex/main.c
+++ b/src/regress/lib/libc/regex/main.c
@@ -1,10 +1,13 @@
+/*      $OpenBSD: main.c,v 1.7 2007/09/12 19:32:35 otto Exp $   */
 /*      $NetBSD: main.c,v 1.2 1995/04/20 22:39:51 cgd Exp $     */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <regex.h>
 #include <assert.h>
+#include <unistd.h>
 
 #include "main.ih"
 
@@ -19,15 +22,15 @@ regoff_t startoff = 0;
 regoff_t endoff = 0;
 
 
-extern int split();
-extern void regprint();
+extern int split(char *, char *[], int, char *);
+extern void regprint(regex_t *, FILE *);
 
 /*
  - main - do the simple case, hand off to regress() for regression
  */
-main(argc, argv)
-int argc;
-char *argv[];
+int
+main(int argc, char *argv[])
+
 {
         regex_t re;
 #       define  NS      10
@@ -43,7 +46,7 @@ char *argv[];
 
         progname = argv[0];
 
-        while ((c = getopt(argc, argv, "c:e:S:E:x")) != EOF)
+        while ((c = getopt(argc, argv, "c:e:S:E:x")) != -1)
                 switch (c) {
                 case 'c':       /* compile options */
                         copts = options('c', optarg);
@@ -79,7 +82,7 @@ char *argv[];
         err = regcomp(&re, argv[optind++], copts);
         if (err) {
                 len = regerror(err, &re, erbuf, sizeof(erbuf));
-                fprintf(stderr, "error %s, %d/%d `%s'\n",
+                fprintf(stderr, "error %s, %zu/%zu `%s'\n",
                         eprint(err), len, sizeof(erbuf), erbuf);
                 exit(status);
         }
@@ -97,15 +100,15 @@ char *argv[];
         err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
         if (err) {
                 len = regerror(err, &re, erbuf, sizeof(erbuf));
-                fprintf(stderr, "error %s, %d/%d `%s'\n",
+                fprintf(stderr, "error %s, %zu/%zu `%s'\n",
                         eprint(err), len, sizeof(erbuf), erbuf);
                 exit(status);
         }
         if (!(copts&REG_NOSUB)) {
-                len = (int)(subs[0].rm_eo - subs[0].rm_so);
+                len = (size_t)(subs[0].rm_eo - subs[0].rm_so);
                 if (subs[0].rm_so != -1) {
                         if (len != 0)
-                                printf("match `%.*s'\n", len,
+                                printf("match `%.*s'\n", (int)len,
                                         argv[optind] + subs[0].rm_so);
                         else
                                 printf("match `'@%.1s\n",
@@ -144,7 +147,7 @@ FILE *in;
                 line++;
                 if (inbuf[0] == '#' || inbuf[0] == '\n')
                         continue;                       /* NOTE CONTINUE */
-                inbuf[strlen(inbuf)-1] = '\0';  /* get rid of stupid \n */
+                inbuf[strcspn(inbuf, "\n")] = '\0';     /* get rid of stupid \n */
                 if (debug)
                         fprintf(stdout, "%d:\n", line);
                 nf = split(inbuf, f, MAXF, "\t\t");
@@ -225,14 +228,14 @@ int opts;			/* may not match f1 */
         char f0copy[1000];
         char f2copy[1000];
 
-        strcpy(f0copy, f0);
+        strlcpy(f0copy, f0, sizeof f0copy);
         re.re_endp = (opts&REG_PEND) ? f0copy + strlen(f0copy) : NULL;
         fixstr(f0copy);
         err = regcomp(&re, f0copy, opts);
         if (err != 0 && (!opt('C', f1) || err != efind(f2))) {
                 /* unexpected error or wrong error */
                 len = regerror(err, &re, erbuf, sizeof(erbuf));
-                fprintf(stderr, "%d: %s error %s, %d/%d `%s'\n",
+                fprintf(stderr, "%d: %s error %s, %d/%zu `%s'\n",
                                         line, type, eprint(err), len,
                                         sizeof(erbuf), erbuf);
                 status = 1;
@@ -249,7 +252,7 @@ int opts;			/* may not match f1 */
                 return;
         }
 
-        strcpy(f2copy, f2);
+        strlcpy(f2copy, f2, sizeof f2copy);
         fixstr(f2copy);
 
         if (options('e', f1)&REG_STARTEND) {
@@ -263,7 +266,7 @@ int opts;			/* may not match f1 */
         if (err != 0 && (f3 != NULL || err != REG_NOMATCH)) {
                 /* unexpected error or wrong error */
                 len = regerror(err, &re, erbuf, sizeof(erbuf));
-                fprintf(stderr, "%d: %s exec error %s, %d/%d `%s'\n",
+                fprintf(stderr, "%d: %s exec error %s, %d/%zu `%s'\n",
                                         line, type, eprint(err), len,
                                         sizeof(erbuf), erbuf);
                 status = 1;
@@ -427,8 +430,9 @@ char *should;
                                 (sub.rm_so != -1 && sub.rm_eo == -1) ||
                                 (sub.rm_so != -1 && sub.rm_so < 0) ||
                                 (sub.rm_eo != -1 && sub.rm_eo < 0) ) {
-                sprintf(grump, "start %ld end %ld", (long)sub.rm_so,
-                                                        (long)sub.rm_eo);
+                snprintf(grump, sizeof grump,
+                    "start %ld end %ld", (long)sub.rm_so,
+                    (long)sub.rm_eo);
                 return(grump);
         }
 
@@ -440,8 +444,9 @@ char *should;
 
         /* check for in range */
         if (sub.rm_eo > strlen(str)) {
-                sprintf(grump, "start %ld end %ld, past end of string",
-                                        (long)sub.rm_so, (long)sub.rm_eo);
+                snprintf(grump, sizeof grump,
+                        "start %ld end %ld, past end of string",
+                        (long)sub.rm_so, (long)sub.rm_eo);
                 return(grump);
         }
 
@@ -451,13 +456,13 @@ char *should;
 
         /* check for not supposed to match */
         if (should == NULL) {
-                sprintf(grump, "matched `%.*s'", len, p);
+                snprintf(grump, sizeof grump, "matched `%.*s'", len, p);
                 return(grump);
         }
 
         /* check for wrong match */
         if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
-                sprintf(grump, "matched `%.*s' instead", len, p);
+                snprintf(grump, sizeof grump, "matched `%.*s' instead", len, p);
                 return(grump);
         }
         if (shlen > 0)
@@ -470,7 +475,7 @@ char *should;
         if (shlen == 0)
                 shlen = 1;      /* force check for end-of-string */
         if (strncmp(p, at, shlen) != 0) {
-                sprintf(grump, "matched null at `%.20s'", p);
+                snprintf(grump, sizeof grump, "matched null at `%.20s'", p);
                 return(grump);
         }
         return(NULL);
@@ -501,10 +506,9 @@ efind(name)
 char *name;
 {
         static char efbuf[100];
-        size_t n;
         regex_t re;
 
-        sprintf(efbuf, "REG_%s", name);
+        snprintf(efbuf, sizeof efbuf, "REG_%s", name);
         assert(strlen(efbuf) < sizeof(efbuf));
         re.re_endp = efbuf;
         (void) regerror(REG_ATOI, &re, efbuf, sizeof(efbuf));
diff --git a/src/regress/lib/libc/regex/main.ih b/src/regress/lib/libc/regex/main.ih
index 135e3e792d..0860e26333 100644
--- a/src/regress/lib/libc/regex/main.ih
+++ b/src/regress/lib/libc/regex/main.ih
@@ -1,3 +1,4 @@
+/*      $OpenBSD: main.ih,v 1.3 2002/02/16 21:27:32 millert Exp $       */
 /*      $NetBSD: main.ih,v 1.2 1995/04/20 22:39:55 cgd Exp $    */
 
 /* ========= begin header generated by ./mkh ========= */
@@ -6,14 +7,14 @@ extern "C" {
 #endif
 
 /* === main.c === */
-void regress __P((FILE *in));
-void try __P((char *f0, char *f1, char *f2, char *f3, char *f4, int opts));
-int options __P((int type, char *s));
-int opt __P((int c, char *s));
-void fixstr __P((register char *p));
-char *check __P((char *str, regmatch_t sub, char *should));
-static char *eprint __P((int err));
-static int efind __P((char *name));
+void regress(FILE *in);
+void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
+int options(int type, char *s);
+int opt(int c, char *s);
+void fixstr(register char *p);
+char *check(char *str, regmatch_t sub, char *should);
+static char *eprint(int err);
+static int efind(char *name);
 
 #ifdef __cplusplus
 }
diff --git a/src/regress/lib/libc/regex/split.c b/src/regress/lib/libc/regex/split.c
index dd1ca14480..fcd81a3503 100644
--- a/src/regress/lib/libc/regex/split.c
+++ b/src/regress/lib/libc/regex/split.c
@@ -1,18 +1,17 @@
+/*      $OpenBSD: split.c,v 1.5 2007/09/09 23:25:12 chl Exp $   */
 /*      $NetBSD: split.c,v 1.2 1995/04/20 22:39:57 cgd Exp $    */
 
 #include <stdio.h>
 #include <string.h>
 
+int split(char *string, char *fields[], int nfields, char *sep);
+
 /*
  - split - divide a string into fields, like awk split()
  = int split(char *string, char *fields[], int nfields, char *sep);
  */
 int                             /* number of fields, including overflow */
-split(string, fields, nfields, sep)
-char *string;
-char *fields[];                 /* list is not NULL-terminated */
-int nfields;                    /* number of entries available in fields[] */
-char *sep;                      /* "" white, "c" single char, "ab" [ab]+ */
+split(char *string, char *fields[], int nfields, char *sep)
 {
         register char *p = string;
         register char c;                        /* latest character */
@@ -161,18 +160,18 @@ char *argv[];
 
         if (argc > 4)
                 for (n = atoi(argv[3]); n > 0; n--) {
-                        (void) strcpy(buf, argv[1]);
+                        (void) strlcpy(buf, argv[1], sizeof buf);
                 }
         else if (argc > 3)
                 for (n = atoi(argv[3]); n > 0; n--) {
-                        (void) strcpy(buf, argv[1]);
+                        (void) strlcpy(buf, argv[1], sizeof buf);
                         (void) split(buf, fields, MNF, argv[2]);
                 }
         else if (argc > 2)
                 dosplit(argv[1], argv[2]);
         else if (argc > 1)
                 while (fgets(buf, sizeof(buf), stdin) != NULL) {
-                        buf[strlen(buf)-1] = '\0';      /* stomp newline */
+                        buf[strcspn(buf, "\n")] = '\0'; /* stomp newline */
                         dosplit(buf, argv[1]);
                 }
         else
@@ -287,7 +286,7 @@ regress()
         register char *f;
 
         for (n = 0; tests[n].str != NULL; n++) {
-                (void) strcpy(buf, tests[n].str);
+                (void) strlcpy(buf, tests[n].str, sizeof buf);
                 fields[RNF] = NULL;
                 nf = split(buf, fields, RNF, tests[n].seps);
                 printit = 0;
diff --git a/src/regress/lib/libc/regex/tests b/src/regress/lib/libc/regex/tests
index 8e89f161b1..c827c868b7 100644
--- a/src/regress/lib/libc/regex/tests
+++ b/src/regress/lib/libc/regex/tests
@@ -1,3 +1,4 @@
+#       $OpenBSD: tests,v 1.5 2004/11/29 16:50:31 otto Exp $
 #       $NetBSD: tests,v 1.5 1995/04/20 22:40:00 cgd Exp $
 
 # regular expression test set
@@ -168,6 +169,30 @@ a\(\(b\)*\2\)*d		b	abbbd	abbbd
 \(a\)\1bc*d     b       aabcccd aabcccd
 \(a\)\1bc*[ce]d b       aabcccd aabcccd
 ^\(a\)\1b\(c\)*cd$      b       aabcccd aabcccd
+\(b*\)\(a*\1\)* b       ab      a
+\([^_]*\)\(_*\1\)*      b       foo_foo_bar_bar_bar_baz foo_foo foo,_foo
+\([^_]*\)\(_*\1\)*      b       bar_bar_bar_baz bar_bar_bar     bar,_bar
+\([^_]*\)\(_*\1\)*      b       foo_bar_baz     foo     foo
+\(.*\)\1        b       ""      ""
+\(.*\)\1        b       a       ""
+\(.*\)\1        b       aa      aa
+\(.*\)\1        b       aaa     aa
+\(.*\)\1        b       aaaa    aaaa
+\([^_]*\)\1     b       ""      ""
+\([^_]*\)\1     b       a       ""
+\([^_]*\)\1     b       aa      aa
+\([^_]*\)\1     b       aaa     aa
+\([^_]*\)\1     b       aaaa    aaaa
+foo\(.*\)bar\1  b       foolbarl        foolbarl        l
+foo\(.*\)bar\1  b       foobar  foobar  ""
+\(\(.\)b\)*\1   b       aba
+\(\(.\)b\)*\1   b       abba
+\(\(.\)b\)*\1   b       abbba
+\(\(.\)b\)*\1   b       abbbba  bbbb    bb,b
+\(\(.\)b\)*\1   b       abbbbba abbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbba        abbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbbbbbbbbbba        abbbbbbbbbbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbbbbbbbbbbba       abbbbbbbbbbbbbbb        bb,b
 
 # ordinary repetitions
 ab*c            &       abc     abc
@@ -475,3 +500,4 @@ CC[13]1|a{21}[23][EO][123][Es][12]a{15}aa[34][EW]aaaaaaa[X]a	-	CC11	CC11
 Char \([a-z0-9_]*\)\[.* b       Char xyz[k      Char xyz[k      xyz
 a?b     -       ab      ab
 -\{0,1\}[0-9]*$ b       -5      -5
+
diff --git a/src/regress/lib/libc/setjmp-signal/Makefile b/src/regress/lib/libc/setjmp-signal/Makefile
new file mode 100644
index 0000000000..a9649a8abe
--- /dev/null
+++ b/src/regress/lib/libc/setjmp-signal/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2002/07/31 05:18:24 art Exp $
+
+PROG=   setjmp-signal
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/setjmp-signal/setjmp-signal.c b/src/regress/lib/libc/setjmp-signal/setjmp-signal.c
new file mode 100644
index 0000000000..310e4052ef
--- /dev/null
+++ b/src/regress/lib/libc/setjmp-signal/setjmp-signal.c
@@ -0,0 +1,26 @@
+/*      $OpenBSD: setjmp-signal.c,v 1.3 2003/01/03 20:46:05 miod Exp $  */
+/*
+ *      Written by Artur Grabowski <art@openbsd.org> 2002 Public Domain.
+ */
+
+#include <setjmp.h>
+#include <signal.h>
+
+jmp_buf jb;
+
+void
+segv_handler(int signum)
+{
+        longjmp(jb, 1);
+}
+
+int
+main()
+{
+        signal(SIGSEGV, segv_handler);
+        if (setjmp(jb) == 0) {
+                *((int *)0L) = 0;
+                return (1);
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/setjmp/Makefile b/src/regress/lib/libc/setjmp/Makefile
index 25bf99d4cb..fc68e8d44c 100644
--- a/src/regress/lib/libc/setjmp/Makefile
+++ b/src/regress/lib/libc/setjmp/Makefile
@@ -1,16 +1,9 @@
+#       $OpenBSD: Makefile,v 1.3 2002/01/01 23:00:51 art Exp $
 #       $NetBSD: Makefile,v 1.2 1995/04/20 22:40:13 cgd Exp $
 
 PROG=   setjmptest
 SRCS=   jmptest.c
-NOMAN=  noman, no way, man
 
 CFLAGS+= -DTEST_SETJMP
 
-.PATH:  ${.CURDIR}/../setjmp
-
-install:
-
-regress: ${PROG}
-        ./${PROG}
-
-.include <bsd.prog.mk>
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/setjmp/jmptest.c b/src/regress/lib/libc/setjmp/jmptest.c
index f2cecc9178..9512c9ee34 100644
--- a/src/regress/lib/libc/setjmp/jmptest.c
+++ b/src/regress/lib/libc/setjmp/jmptest.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: jmptest.c,v 1.7 2003/09/02 23:52:16 david Exp $       */
 /*      $NetBSD: jmptest.c,v 1.2 1995/01/01 20:55:35 jtc Exp $  */
 
 /*
@@ -32,10 +33,12 @@
  */
 
 #include <sys/types.h>
+#include <err.h>
 #include <setjmp.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
 #if (TEST_SETJMP + TEST_U_SETJMP + TEST_SIGSETJMP) != 1
@@ -62,21 +65,20 @@
 
 int expectsignal;
 
-void
-aborthandler(signo)
-        int signo;
+static void
+aborthandler(int signo)
 {
 
         if (expectsignal)
-                exit(0);
-        else
-                errx(1, "kill(SIGABRT) succeeded");
+                _exit(0);
+        else {
+                warnx("kill(SIGABRT) succeeded");
+                _exit(1);
+        }
 }
 
 int
-main(argc, argv)
-        int argc;
-        char *argv[];
+main(int argc, char *argv[])
 {
         struct sigaction sa;
         BUF jb;
@@ -101,7 +103,7 @@ main(argc, argv)
 #endif
 
         sa.sa_handler = aborthandler;
-        sa.sa_mask = 0;
+        sigemptyset(&sa.sa_mask);
         sa.sa_flags = 0;
         if (sigaction(SIGABRT, &sa, NULL) == -1)
                 err(1, "sigaction failed");
diff --git a/src/regress/lib/libc/sigreturn/Makefile b/src/regress/lib/libc/sigreturn/Makefile
new file mode 100644
index 0000000000..9891ba9e05
--- /dev/null
+++ b/src/regress/lib/libc/sigreturn/Makefile
@@ -0,0 +1,18 @@
+# $OpenBSD: Makefile,v 1.5 2002/09/02 20:01:43 avsm Exp $
+
+PROG=   sigret
+
+DEBUG+= -ggdb
+
+REGRESS_TARGETS+= sigret-normal sigret-indirect sigret-altstack
+
+sigret-normal: ${PROG}
+        ./${PROG}
+
+sigret-indirect: ${PROG}
+        ./${PROG} -i
+
+sigret-altstack: ${PROG}
+        ./${PROG} -a
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/sigreturn/sigret.c b/src/regress/lib/libc/sigreturn/sigret.c
new file mode 100644
index 0000000000..72945fa503
--- /dev/null
+++ b/src/regress/lib/libc/sigreturn/sigret.c
@@ -0,0 +1,181 @@
+/*
+ * $OpenBSD: sigret.c,v 1.5 2003/07/31 21:48:04 deraadt Exp $
+ *
+ * Public Domain
+ *
+ * Playing games with sigreturn.   Check if calling sigreturn from a
+ * signal handler screws anything up.
+ *
+ * Run with:
+ *      -a:     use an alternate signal stack
+ *
+ *      -b:     call sigreturn from outside of a signal handler
+ *              An error is OK
+ *
+ *      -c:     clobber the sigcontext before calling sigreturn
+ *              the program should die
+ *
+ *      -f:     don't use sigreturn -- fall through the signal handler
+ *              -c, and -i options ignored when used
+ *
+ *      -i:     call sigreturn from a function called by the signal handler
+ *
+ */
+
+#include <sys/time.h>
+
+#include <err.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*
+ * sigalarm occurs 50 times/second.  Stop running after 10 seconds
+ * (100 interrupts).
+ */
+#define MAX_INTERRUPTS  500
+
+int failed;
+int altstack;
+int badcall;
+int clobbercall;
+int fallthru;
+int indirect;
+
+volatile int count;
+struct sigcontext gscp;
+int gscp_loaded;
+
+static void
+usage(const char * err, ...)
+{
+        extern const char * __progname;
+
+        if (err) {
+                va_list ap;
+                va_start(ap, err);
+                vwarnx(err, ap);
+                va_end(ap);
+        }
+        fprintf(stderr, "usage: %s [-abcfi]\n", __progname);
+        exit(1);
+}
+
+static void
+indirect_return(struct sigcontext * scp)
+{
+        sigreturn(scp);
+}
+
+static void
+sig_handler(int sig, siginfo_t *blah, void *x)
+{
+        struct sigcontext * scp = x;
+
+        count++;
+
+        if (!fallthru) {
+                if (clobbercall)
+                        memset(scp, 0, sizeof *scp);
+                if (indirect)
+                        indirect_return(scp);
+                else if (badcall) {
+                        gscp = *scp;
+                        gscp_loaded = 1;
+                } else
+                        sigreturn(scp);
+        }
+}
+
+static void
+test2(char *fmt)
+{
+        char *ofmt = fmt;
+
+        if (gscp_loaded) {
+                gscp_loaded = 0;
+                sigreturn(&gscp);
+        }
+
+        for (; *fmt; fmt++)
+          switch (*fmt) {
+          case 'i':
+          case 'c':
+          case 'l':
+          case 'p':
+            break;
+          default:
+            failed = 1;
+            fprintf(stderr,
+                    "unexpected character 0x%02x `%c' in %s: count %d\n",
+                    *fmt, *fmt, ofmt, count);
+          }
+}
+
+int
+main(int argc, char * argv[])
+{
+        extern char *optarg;
+        extern int optind;
+
+        int opt;
+
+        struct sigaction act;
+        struct sigaltstack ss;
+
+        while ((opt = getopt(argc, argv, "abcfi")) != -1) {
+                switch (opt) {
+                case 'a':
+                        /* use sigaltstack */
+                        altstack = 1;
+                        break;
+                case 'b':
+                        /* call outside of sig_handler */
+                        badcall = 1;
+                        break;
+                case 'c':
+                        /* force error by munging sigcontext */
+                        clobbercall = 1;
+                        break;
+                case 'f':
+                        /* don't use sigreturn */
+                        fallthru = 1;
+                        break;
+                case 'i':
+                        /* call sigreturn indirectly */
+                        indirect = 1;
+                        break;
+                }
+        }
+
+        /* make sure there is no other cruft left on the command line */
+        if (optind != argc)
+                usage("unknown argument -- %s", argv[ optind ]);
+
+        if (altstack) {
+                if ((ss.ss_sp = malloc(SIGSTKSZ)) == NULL)
+                        errx(1, "ss_sp malloc");
+
+                ss.ss_size = SIGSTKSZ;
+                ss.ss_flags = 0;
+                if (sigaltstack(&ss,0) == -1)
+                        err(1, "sigaltstack");
+        }
+
+        sigfillset(&act.sa_mask);
+        act.sa_sigaction = sig_handler;
+        act.sa_flags = SA_RESTART;
+        if (altstack)
+                act.sa_flags |= SA_ONSTACK;
+        sigaction(SIGALRM, &act, NULL);
+
+        ualarm(10000, 10000);
+
+        while (count < MAX_INTERRUPTS)
+                test2("iclp");
+
+        return failed;
+}
diff --git a/src/regress/lib/libc/sigsetjmp/Makefile b/src/regress/lib/libc/sigsetjmp/Makefile
index 41682fcb66..f88bea3b47 100644
--- a/src/regress/lib/libc/sigsetjmp/Makefile
+++ b/src/regress/lib/libc/sigsetjmp/Makefile
@@ -1,17 +1,19 @@
-#       $NetBSD: Makefile,v 1.2 1995/04/20 22:40:40 cgd Exp $
+#       $OpenBSD: Makefile,v 1.5 2002/09/02 20:01:43 avsm Exp $
 
 PROG=   sigsetjmptest
 SRCS=   jmptest.c
-NOMAN=  noman, no way, man
 
 CFLAGS+= -DTEST_SIGSETJMP
 
 .PATH:  ${.CURDIR}/../setjmp
 
-install:
+REGRESS_TARGETS=sigsetjmp-save sigsetjmp-nosave
 
-regress: ${PROG}
+sigsetjmp-save: ${PROG}
         ./${PROG} save
+sigsetjmp-nosave: ${PROG}
         ./${PROG} nosave
 
-.include <bsd.prog.mk>
+.PHONY: ${REGRESS_TARGETS}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/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/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..ee602a4b13
--- /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
+User defined signal 2
+Unknown signal: 32
+Unknown signal: 100
+Unknown signal: 2147483647
+Unknown signal: 2147483648
+Unknown signal: 4294967295
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..40e5d9f503
--- /dev/null
+++ b/src/regress/lib/libc/vis/vis_test.c
@@ -0,0 +1,23 @@
+/*      $OpenBSD */
+
+/* Public domain. 2005, Otto Moerbeek */
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <vis.h>
+
+int
+main()
+{
+        char inp[UCHAR_MAX + 1];
+        char out[4 * UCHAR_MAX + 1];
+        int i;
+
+        for (i = 0; i <= UCHAR_MAX; i++) {
+                inp[i] = i;
+        }
+        strvisx(out, inp, UCHAR_MAX + 1, 0);
+        printf("%s\n", out);
+        exit(0);
+}