Optional SIMD strlen (#586)

This is a potential first step at upstreaming #580 piecemeal.

Chose `strlen` as it's already covered by tests. It's also one of the
simplest (easiest to review) implementations.

Built and tested with:
```sh
CC=[PATH_TO]/wasi-sdk-25.0-x86_64-linux/bin/clang \
  EXTRA_CFLAGS="-O2 -DNDEBUG -msimd128 -mbulk-memory -D__wasilibc_simd_string" make
(cd test ; CC=[PATH_TO]/wasi-sdk-25.0-x86_64-linux/bin/clang make )
```

Author: ncruces

.github/workflows/main.yml

@@ -110,6 +110,15 @@ jobs:
               TARGET_TRIPLE: wasm32-wasip1-threads
               THREAD_MODEL: posix
 
+          - name: Test wasm32-wasi-simd
+            os: ubuntu-24.04
+            clang_version: 16
+            test: true
+            upload: wasm32-wasi-simd
+            env:
+              MAKE_TARGETS: "no-check-symbols"
+              EXTRA_CFLAGS: "-O2 -DNDEBUG -msimd128 -mrelaxed-simd -mbulk-memory -D__wasilibc_simd_string"
+
     steps:
     - uses: actions/checkout@v4.1.7
       with:

Makefile

@@ -808,11 +808,13 @@ $(DUMMY_LIBS):
 	    $(AR) crs "$$lib"; \
 	done
 
-finish: $(STARTUP_FILES) libc $(DUMMY_LIBS)
+no-check-symbols: $(STARTUP_FILES) libc $(DUMMY_LIBS)
 	#
 	# The build succeeded! The generated sysroot is in $(SYSROOT).
 	#
 
+finish: no-check-symbols
+
 ifeq ($(LTO),no)
 # The check for defined and undefined symbols expects there to be a heap
 # allocator (providing malloc, calloc, free, etc). Skip this step if the build
@@ -1033,4 +1035,4 @@ clean:
 	$(RM) -r "$(OBJDIR)"
 	$(RM) -r "$(SYSROOT)"
 
-.PHONY: default libc libc_so finish install clean check-symbols bindings
+.PHONY: default libc libc_so finish install clean check-symbols no-check-symbols bindings

libc-top-half/musl/src/string/strlen.c

@@ -2,13 +2,47 @@
 #include <stdint.h>
 #include <limits.h>
 
+#ifdef __wasm_simd128__
+#include <wasm_simd128.h>
+#endif
+
 #define ALIGN (sizeof(size_t))
 #define ONES ((size_t)-1/UCHAR_MAX)
 #define HIGHS (ONES * (UCHAR_MAX/2+1))
 #define HASZERO(x) ((x)-ONES & ~(x) & HIGHS)
 
 size_t strlen(const char *s)
 {
+#if defined(__wasm_simd128__) && defined(__wasilibc_simd_string)
+	// strlen must stop as soon as it finds the terminator.
+	// Aligning ensures loads beyond the terminator are safe.
+	// Casting through uintptr_t makes this implementation-defined,
+	// rather than undefined behavior.
+	uintptr_t align = (uintptr_t)s % sizeof(v128_t);
+	const v128_t *v = (v128_t *)((uintptr_t)s - align);
+
+	for (;;) {
+		// Bitmask is slow on AArch64, all_true is much faster.
+		if (!wasm_i8x16_all_true(*v)) {
+			const v128_t cmp = wasm_i8x16_eq(*v, (v128_t){});
+			// Clear the bits corresponding to align (little-endian)
+			// so we can count trailing zeros.
+			int mask = wasm_i8x16_bitmask(cmp) >> align << align;
+			// At least one bit will be set, unless align cleared them.
+			// Knowing this helps the compiler if it unrolls the loop.
+			__builtin_assume(mask || align);
+			// If the mask became zero because of align,
+			// it's as if we didn't find anything.
+			if (mask) {
+				// Find the offset of the first one bit (little-endian).
+				return (char *)v - s + __builtin_ctz(mask);
+			}
+		}
+		align = 0;
+		v++;
+	}
+#endif
+
 	const char *a = s;
 #ifdef __GNUC__
 	typedef size_t __attribute__((__may_alias__)) word;

test/src/misc/strlen.c

@@ -0,0 +1,40 @@
+//! add-flags.py(LDFLAGS): -Wl,--stack-first -Wl,--initial-memory=327680
+
+#include <__macro_PAGESIZE.h>
+#include <stdio.h>
+#include <string.h>
+
+void test(char *ptr, size_t want) {
+  size_t got = strlen(ptr);
+  if (got != want) {
+    printf("strlen(%p) = %lu, want %lu\n", ptr, got, want);
+  }
+}
+
+int main(void) {
+  char *const LIMIT = (char *)(__builtin_wasm_memory_size(0) * PAGESIZE);
+
+  for (size_t length = 0; length < 64; length++) {
+    for (size_t alignment = 0; alignment < 24; alignment++) {
+      // Create a string with the given length, at a pointer with the given
+      // alignment. Using the offset LIMIT - PAGESIZE - 8 means many strings
+      // will straddle a (Wasm, and likely OS) page boundary.
+      char *ptr = LIMIT - PAGESIZE - 8 + alignment;
+      memset(LIMIT - 2 * PAGESIZE, 0, 2 * PAGESIZE);
+      memset(ptr, 5, length);
+      test(ptr, length);
+
+      // Make sure we're not fooled by non-zero characters prior to the string.
+      ptr[-1] = 5;
+      test(ptr, length);
+    }
+
+    // Ensure we never read past the end of memory.
+    char *ptr = LIMIT - length - 1;
+    memset(LIMIT - 2 * PAGESIZE, 0, 2 * PAGESIZE);
+    memset(ptr, 5, length);
+    test(ptr, length);
+  }
+
+  return 0;
+}