Index: strnlen.c
===================================================================
diff --git a/head/lib/libc/string/strnlen.c b/head/lib/libc/string/strnlen.c
--- a/head/lib/libc/string/strnlen.c	(revision 250951)
+++ b/head/lib/libc/string/strnlen.c	(working copy)
@@ -1,5 +1,6 @@
 /*-
- * Copyright (c) 2009 David Schultz <das@FreeBSD.org>
+ * Copyright (c) 2009, 2010 Xin LI <delphij@FreeBSD.org>
+ * Copyright (c) 2013 Lee Thomas <lee_thomas@AslanTools.com>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,16 +28,91 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
+#include <sys/limits.h>
+#include <sys/types.h>
 #include <string.h>
 
+/*
+ * Portable strnlen() for 32-bit and 64-bit systems.
+ *
+ * Rationale: it is generally much more efficient to do word length
+ * operations and avoid branches on modern computer systems, as
+ * compared to byte-length operations with a lot of branches.
+ *
+ * The expression:
+ *
+ *	((x - 0x01....01) & ~x & 0x80....80)
+ *
+ * would evaluate to a non-zero value iff any of the bytes in the
+ * original word is zero.
+ *
+ * On multi-issue processors, we can divide the above expression into:
+ *	a)  (x - 0x01....01)
+ *	b) (~x & 0x80....80)
+ *	c) a & b
+ *
+ * Where, a) and b) can be partially computed in parallel.
+ *
+ * The algorithm above is found on "Hacker's Delight" by
+ * Henry S. Warren, Jr.
+ */
+
+/* Magic numbers for the algorithm */
+#if LONG_BIT == 32
+static const unsigned long mask01 = 0x01010101;
+static const unsigned long mask80 = 0x80808080;
+#elif LONG_BIT == 64
+static const unsigned long mask01 = 0x0101010101010101;
+static const unsigned long mask80 = 0x8080808080808080;
+#else
+#error Unsupported word size
+#endif
+
+#define	LONGPTR_MASK (sizeof(long) - 1)
+
 size_t
-strnlen(const char *s, size_t maxlen)
+strnlen(const char *str, size_t maxlen)
 {
-	size_t len;
+	const char *stop, *short_stop;
+	const char *p;
+	const unsigned long *lp;
+	long va, vb;
 
-	for (len = 0; len < maxlen; len++, s++) {
-		if (!*s)
-			break;
+	if (maxlen==0) return 0;
+
+	stop=str+maxlen;
+	/*
+	 * Before trying the hard (unaligned byte-by-byte access) way
+	 * to figure out whether there is a nul character, try to see
+	 * if there is a nul character is within this accessible word
+	 * first.
+	 *
+	 * p and (p & ~LONGPTR_MASK) must be equally accessible since
+	 * they always fall in the same memory page, as long as page
+	 * boundaries is integral multiple of word size.
+	 */
+	lp = (const unsigned long *)((uintptr_t)str & ~LONGPTR_MASK);
+	va = (*lp - mask01);
+	vb = ((~*lp) & mask80);
+	lp++;
+	if (va & vb) {
+		/* Check if we have \0 in the first part */
+		short_stop=(const char *)lp;
+		if (stop<short_stop) short_stop=stop;
+		for (p=str; p != short_stop; p++)
+			if (*p == '\0')
+				return (p-str);
 	}
-	return (len);
+	/* Scan the rest of the string using word sized operation */
+	for (; (const char *)lp < stop; lp++) {
+		va = (*lp - mask01);
+		vb = ((~*lp) & mask80);
+		if (va & vb) {
+			for (p=(const char *)lp; p != stop; p++)
+				if (*p == '\0')
+					break;
+			return (p-str);
+		}
+	}
+	return (maxlen);
 }
