Perform some code cleanup

libc/str/memchr.c

@@ -70,9 +70,7 @@ noasan static inline const unsigned char *memchr_sse(const unsigned char *s,
 void *memchr(const void *s, int c, size_t n) {
   const void *r;
   if (!IsTiny() && X86_HAVE(SSE)) {
-    if (IsAsan()) {
-      __asan_verify(s, n);
-    }
+    if (IsAsan()) __asan_verify(s, n);
     r = memchr_sse(s, c, n);
   } else {
     r = memchr_pure(s, c, n);

libc/str/memrchr.c

@@ -68,9 +68,7 @@ noasan static inline const unsigned char *memrchr_sse(const unsigned char *s,
 void *memrchr(const void *s, int c, size_t n) {
   const void *r;
   if (!IsTiny() && X86_HAVE(SSE)) {
-    if (IsAsan()) {
-      __asan_verify(s, n);
-    }
+    if (IsAsan()) __asan_verify(s, n);
     r = memrchr_sse(s, c, n);
   } else {
     r = memrchr_pure(s, c, n);

libc/str/memrchr16.c

@@ -0,0 +1,76 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or 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 "libc/dce.h"
+#include "libc/intrin/asan.internal.h"
+#include "libc/nexgen32e/x86feature.h"
+#include "libc/str/str.h"
+
+typedef char16_t xmm_t __attribute__((__vector_size__(16), __aligned__(2)));
+
+static inline const char16_t *memrchr16_pure(const char16_t *s, char16_t c,
+                                             size_t n) {
+  size_t i;
+  for (i = n; i--;) {
+    if (s[i] == c) {
+      return s + i;
+    }
+  }
+  return 0;
+}
+
+noasan static inline const char16_t *memrchr16_sse(const char16_t *s,
+                                                   char16_t c, size_t n) {
+  size_t i;
+  unsigned k, m;
+  xmm_t v, t = {c, c, c, c, c, c, c, c};
+  for (i = n; i >= 8;) {
+    v = *(const xmm_t *)(s + (i -= 8));
+    m = __builtin_ia32_pmovmskb128(v == t);
+    if (m) {
+      m = __builtin_clzl(m) ^ (sizeof(long) * CHAR_BIT - 1);
+      return s + i + m / 2;
+    }
+  }
+  while (i--) {
+    if (s[i] == c) {
+      return s + i;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Returns pointer to first instance of character.
+ *
+ * @param s is memory to search
+ * @param c is search byte which is masked with 65535
+ * @param n is number of char16_t elements in `s`
+ * @return is pointer to first instance of c or NULL if not found
+ * @asyncsignalsafe
+ */
+void *memrchr16(const void *s, int c, size_t n) {
+  const void *r;
+  if (!IsTiny() && X86_HAVE(SSE)) {
+    if (IsAsan()) __asan_verify(s, n * 2);
+    r = memrchr16_sse(s, c, n);
+  } else {
+    r = memrchr16_pure(s, c, n);
+  }
+  return (void *)r;
+}

libc/str/str.h

@@ -88,7 +88,6 @@ void *memmove(void *, const void *, size_t) memcpyesque;
 void *memcpy(void *restrict, const void *restrict, size_t) memcpyesque;
 void *mempcpy(void *restrict, const void *restrict, size_t) memcpyesque;
 void *memccpy(void *restrict, const void *restrict, int, size_t) memcpyesque;
-void *memeqmask(void *, const void *, const void *, size_t) memcpyesque;
 void bcopy(const void *, void *, size_t) memcpyesque;
 void explicit_bzero(void *, size_t);
 
@@ -173,7 +172,6 @@ wchar_t *wcsncat(wchar_t *, const wchar_t *, size_t) memcpyesque;
 char *strncpy(char *, const char *, size_t) memcpyesque;
 char *strtok(char *, const char *) paramsnonnull((2)) libcesque;
 char *strtok_r(char *, const char *, char **) paramsnonnull((2, 3));
-uint16_t *strcpyzbw(uint16_t *, const char *) memcpyesque;
 wchar_t *wcstok(wchar_t *, const wchar_t *, wchar_t **) paramsnonnull((2, 3));
 char *wstrtrunc(uint16_t *) memcpyesque;
 char *wstrntrunc(uint16_t *, size_t) memcpyesque;

libc/str/strcmp.c

@@ -20,10 +20,7 @@
 #include "libc/str/str.h"
 
 static inline noasan uint64_t UncheckedAlignedRead64(const char *p) {
-  return (uint64_t)(255 & p[7]) << 070 | (uint64_t)(255 & p[6]) << 060 |
-         (uint64_t)(255 & p[5]) << 050 | (uint64_t)(255 & p[4]) << 040 |
-         (uint64_t)(255 & p[3]) << 030 | (uint64_t)(255 & p[2]) << 020 |
-         (uint64_t)(255 & p[1]) << 010 | (uint64_t)(255 & p[0]) << 000;
+  return *(uint64_t *)p;
 }
 
 /**

libc/str/strnlen.c

@@ -18,12 +18,14 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/bits/bits.h"
+#include "libc/dce.h"
+#include "libc/intrin/asan.internal.h"
 #include "libc/str/str.h"
 
 static noasan size_t strnlen_x64(const char *s, size_t n, size_t i) {
   uint64_t w;
   for (; i + 8 < n; i += 8) {
-    w = READ64LE(s + i);
+    w = *(uint64_t *)(s + i);
     if ((w = ~w & (w - 0x0101010101010101) & 0x8080808080808080)) {
       i += (unsigned)__builtin_ctzll(w) >> 3;
       break;
@@ -40,8 +42,9 @@ static noasan size_t strnlen_x64(const char *s, size_t n, size_t i) {
  * @return byte length
  * @asyncsignalsafe
  */
-size_t strnlen(const char *s, size_t n) {
+noasan size_t strnlen(const char *s, size_t n) {
   size_t i;
+  if (IsAsan() && n) __asan_verify(s, 1);
   for (i = 0; (uintptr_t)(s + i) & 7; ++i) {
     if (i == n || !s[i]) return i;
   }
@@ -50,5 +53,6 @@ size_t strnlen(const char *s, size_t n) {
     if (i == n || !s[i]) break;
   }
   assert(i == n || (i < n && !s[i]));
+  if (IsAsan()) __asan_verify(s, i);
   return i;
 }

libc/str/strnlen_s.c

@@ -0,0 +1,61 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or 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 "libc/assert.h"
+#include "libc/dce.h"
+#include "libc/intrin/asan.internal.h"
+#include "libc/str/str.h"
+
+static noasan size_t strnlen_s_x64(const char *s, size_t n, size_t i) {
+  uint64_t w;
+  for (; i + 8 < n; i += 8) {
+    w = *(uint64_t *)(s + i);
+    if ((w = ~w & (w - 0x0101010101010101) & 0x8080808080808080)) {
+      i += (unsigned)__builtin_ctzll(w) >> 3;
+      break;
+    }
+  }
+  return i;
+}
+
+/**
+ * Returns length of NUL-terminated string... securely.
+ *
+ * This is like strnlen() except it'll return 0 if `s` is null. We also
+ * make the assumption for the purposes of ASAN that `n` is the size of
+ * the buffer if `s` is non-null.
+ *
+ * @param s is string
+ * @param n is max length
+ * @return byte length
+ * @asyncsignalsafe
+ */
+noasan size_t strnlen_s(const char *s, size_t n) {
+  size_t i;
+  if (!s) return 0;
+  if (IsAsan()) __asan_verify(s, n);
+  for (i = 0; (uintptr_t)(s + i) & 7; ++i) {
+    if (i == n || !s[i]) return i;
+  }
+  i = strnlen_s_x64(s, n, i);
+  for (;; ++i) {
+    if (i == n || !s[i]) break;
+  }
+  assert(i == n || (i < n && !s[i]));
+  return i;
+}

libc/str/wmemrchr.c

@@ -0,0 +1,76 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or 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 "libc/dce.h"
+#include "libc/intrin/asan.internal.h"
+#include "libc/nexgen32e/x86feature.h"
+#include "libc/str/str.h"
+
+typedef wchar_t xmm_t __attribute__((__vector_size__(16), __aligned__(4)));
+
+static inline const wchar_t *wmemrchr_pure(const wchar_t *s, wchar_t c,
+                                           size_t n) {
+  size_t i;
+  for (i = n; i--;) {
+    if (s[i] == c) {
+      return s + i;
+    }
+  }
+  return 0;
+}
+
+noasan static inline const wchar_t *wmemrchr_sse(const wchar_t *s, wchar_t c,
+                                                 size_t n) {
+  size_t i;
+  unsigned k, m;
+  xmm_t v, t = {c, c, c, c};
+  for (i = n; i >= 4;) {
+    v = *(const xmm_t *)(s + (i -= 4));
+    m = __builtin_ia32_pmovmskb128(v == t);
+    if (m) {
+      m = __builtin_clzl(m) ^ (sizeof(long) * CHAR_BIT - 1);
+      return s + i + m / 4;
+    }
+  }
+  while (i--) {
+    if (s[i] == c) {
+      return s + i;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Returns pointer to first instance of character.
+ *
+ * @param s is memory to search
+ * @param c is search word
+ * @param n is number of wchar_t elements in `s`
+ * @return is pointer to first instance of c or NULL if not found
+ * @asyncsignalsafe
+ */
+void *wmemrchr(const void *s, wchar_t c, size_t n) {
+  const void *r;
+  if (!IsTiny() && X86_HAVE(SSE)) {
+    if (IsAsan()) __asan_verify(s, n * 4);
+    r = wmemrchr_sse(s, c, n);
+  } else {
+    r = wmemrchr_pure(s, c, n);
+  }
+  return (void *)r;
+}