@amritk/nish-x86_64-linux 0.16.0 → 0.18.0

package/runtime/runtime-host.c

@@ -156,46 +156,65 @@ _Bool nish_is_executable(const nish_str *path) {
  * async-signal-safe. The write end is non-blocking, so a thousand unread
  * signals lose the newest rather than wedge the handler, and `errno` is put
  * back for the code the signal interrupted. The descriptor is made once and
- * every later `signalFd()` answers the same one. */
-static int nish_signal_read_end = -1;
-static int nish_signal_write_end = -1;
+ * every later `signalFd()` answers the same one.
+ *
+ * Both ends live in one word, the read end in the high half and the write end
+ * in the low, -1 until the pipe exists, so that publishing them is a single
+ * compare-and-swap (docs/security/runtime.md, RT-10). Two threads whose first
+ * calls overlap can each make a pipe; one swap wins, the other caller closes
+ * its own pipe and answers the winner's read end. With two separate words the
+ * call that finished last answered its own pipe while the handler wrote to
+ * the other, so one caller never heard a signal and a pipe leaked. Each first
+ * caller installs the handler itself before it returns, so neither can hand
+ * back a descriptor before a signal reaches it. */
+static int64_t nish_signal_pipe = -1;
 
 static void nish_on_signal(int sig) {
   int saved = errno;
   unsigned char b = (unsigned char)sig;
-  (void)!write(nish_signal_write_end, &b, 1);
+  /* The low half: the write end. */
+  (void)!write((int)__atomic_load_n(&nish_signal_pipe, __ATOMIC_RELAXED), &b, 1);
   errno = saved;
 }
 
 int32_t nish_signal_fd(void) {
-  if (nish_signal_read_end >= 0) return nish_signal_read_end;
-  int p[2];
+  int64_t cur = __atomic_load_n(&nish_signal_pipe, __ATOMIC_ACQUIRE);
+  if (cur < 0) {
+    int p[2];
 #if defined(__linux__)
-  /* Both ends close-on-exec from the moment they exist, so a child a sibling
-     thread spawns meanwhile cannot inherit either. */
-  if (pipe2(p, O_CLOEXEC) != 0) return -1;
+    /* Both ends close-on-exec from the moment they exist, so a child a sibling
+       thread spawns meanwhile cannot inherit either. */
+    if (pipe2(p, O_CLOEXEC) != 0) return -1;
 #else
-  /* Darwin has no `pipe2`, so there is a window between `pipe` and the two
-     `fcntl`s in which a child spawned by another thread inherits the ends. */
-  if (pipe(p) != 0) return -1;
-  fcntl(p[0], F_SETFD, FD_CLOEXEC);
-  fcntl(p[1], F_SETFD, FD_CLOEXEC);
+    /* Darwin has no `pipe2`, so there is a window between `pipe` and the two
+       `fcntl`s in which a child spawned by another thread inherits the ends. */
+    if (pipe(p) != 0) return -1;
+    fcntl(p[0], F_SETFD, FD_CLOEXEC);
+    fcntl(p[1], F_SETFD, FD_CLOEXEC);
 #endif
-  fcntl(p[1], F_SETFL, O_NONBLOCK);
-  nish_signal_write_end = p[1];
-  struct sigaction sa;
-  sa.sa_handler = nish_on_signal;
-  sa.sa_flags = SA_RESTART;
-  sigemptyset(&sa.sa_mask);
-  sigaction(SIGINT, &sa, 0);
-  sigaction(SIGTERM, &sa, 0);
-  return nish_signal_read_end = p[0];
+    fcntl(p[1], F_SETFL, O_NONBLOCK);
+    int64_t mine = (int64_t)p[0] << 32 | (uint32_t)p[1];
+    /* A failed swap leaves the winner's pair in `cur`. */
+    if (__atomic_compare_exchange_n(&nish_signal_pipe, &cur, mine, 0, __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE)) {
+      cur = mine;
+    } else {
+      close(p[0]);
+      close(p[1]);
+    }
+    struct sigaction sa;
+    sa.sa_handler = nish_on_signal;
+    sa.sa_flags = SA_RESTART;
+    sigemptyset(&sa.sa_mask);
+    sigaction(SIGINT, &sa, 0);
+    sigaction(SIGTERM, &sa, 0);
+  }
+  return (int32_t)(cur >> 32);
 }
 
 /* Block until a signal's byte arrives and answer it: 15 or 2, or -1 for any
    `fd` that is not the signal descriptor and for a read that fails. */
 int32_t nish_read_signal(int32_t fd) {
-  if (fd != nish_signal_read_end) return -1;
+  if (fd != (int32_t)(__atomic_load_n(&nish_signal_pipe, __ATOMIC_ACQUIRE) >> 32)) return -1;
   unsigned char b;
   ssize_t n;
   do n = read(fd, &b, 1);

package/runtime/runtime-net.c

@@ -12,13 +12,15 @@
  * scripts/build.sh pairs this file with runtime.c like the other halves, so a
  * link line still names one runtime.
  *
- * The error convention is the one `signalFd` set: an `i32`, `>= 0` for
- * success (a descriptor, a byte count, 0), and a negative errno otherwise.
- * The codes a loop branches on are Linux's numbers on every platform (-11
+ * Errors take the shape `signalFd` set, an `i32` that is `>= 0` for success
+ * (a descriptor, a byte count, 0) and negative for a failure, and add the
+ * errno to it: where `signalFd` and `readSignal` answer a plain -1, a call
+ * here answers the failure's errno, negated. The codes a loop branches on are Linux's numbers on every platform (-11
  * would block, -95 unsupported, -32 the peer is gone, -104 reset, -98 the
- * address is in use, -22 a bad argument), so `nish_net_err` translates
- * Darwin's; any other failure is the host's own `-errno`. Nothing here
- * allocates: the addresses a call reads or writes are the caller's `u8[]`.
+ * address is in use, -111 refused, -110 timed out, -22 a bad argument), so
+ * `nish_net_err` translates Darwin's; any other failure is the host's own
+ * `-errno`. Nothing here allocates: the addresses a call reads or writes are
+ * the caller's `u8[]`.
  *
  * An address is 18 bytes of that array: the 16 bytes of an IPv6 address, an
  * IPv4 one as `::ffff:a.b.c.d`, then the port, big-endian. An IPv4 address is
@@ -33,7 +35,10 @@
  * both, never SIGPIPE), the errno numbers, UDP's segmentation offload
  * (`UDP_SEGMENT`, `UDP_GRO`) and ECN marks, which Linux has and for which
  * Darwin answers -95, and the readiness loop, which is epoll on Linux and
- * kqueue on Darwin. The Darwin branch is compiled by CI's Darwin bootstrap
+ * kqueue on Darwin. Only the sending side and the GRO bind say -95 there: a
+ * receive leaves `meta` at 0, 0, and a `meta[1]` of 0 is also what a real
+ * Not-ECT datagram reads as, so a program learns that Darwin has no ECN from
+ * the send, never from the receive. The Darwin branch is compiled by CI's Darwin bootstrap
  * rows and run by nothing. A WASI build has none of this (the checker refuses
  * every `nish:net` call under a wasm target), so there the file is empty.
  */
@@ -91,6 +96,8 @@ static int32_t nish_net_err(int e) {
   if (e == EOPNOTSUPP || e == ENOTSUP) return -95;
   if (e == ECONNRESET) return -104;
   if (e == EADDRINUSE) return -98;
+  if (e == ECONNREFUSED) return -111;
+  if (e == ETIMEDOUT) return -110;
 #endif
   return -e;
 }
@@ -111,8 +118,11 @@ static int nish_net_parse(const nish_str *s, unsigned char a[16]) {
   return inet_pton(AF_INET6, host, a) == 1;
 }
 
-/* `a` and `port` as a socket address of the family `v4` names. */
-static socklen_t nish_net_sockaddr(nish_sockaddr *s, const unsigned char a[16], int32_t port, int v4) {
+/* `a` and `port` as a socket address of the family `v4` names. `noinline`:
+   three calls share one body, which inlined into each was 42 bytes more of
+   `.text` than the calls cost. */
+__attribute__((noinline)) static socklen_t nish_net_sockaddr(nish_sockaddr *s, const unsigned char a[16],
+                                                             int32_t port, int v4) {
   memset(s, 0, sizeof *s);
   if (v4) {
     s->v4.sin_family = AF_INET;
@@ -269,6 +279,41 @@ int32_t nish_tcp_accept(int32_t fd, nish_array *peer) {
   return c;
 }
 
+/* `tcpConnect(addr)`: a new socket, non-blocking and close-on-exec, connecting
+   to the address in `addr`; an IPv4 one is an `AF_INET` socket, any other
+   `AF_INET6`. A non-blocking `connect` seldom finishes at once (on Linux not
+   even over loopback), and its `EINPROGRESS` (-115) is not a failure: the
+   descriptor is answered all the same, and the connection is made once the
+   loop reports it writable, when `connectResult` says how it went. Any other
+   failure closes the socket and is answered instead of it. An `addr` shorter
+   than 18 bytes is -22 before any socket exists. */
+int32_t nish_tcp_connect(const nish_array *addr) {
+  if (addr->len < NISH_ADDR_BYTES) return -22;
+  const unsigned char *p = (const unsigned char *)addr->data;
+  int v4 = memcmp(p, nish_mapped_prefix, 12) == 0;
+  int fd = nish_net_socket(v4 ? AF_INET : AF_INET6, SOCK_STREAM);
+  if (fd < 0) return nish_net_fail();
+  nish_sockaddr s;
+  socklen_t n = nish_net_sockaddr(&s, p, (p[16] << 8) | p[17], v4);
+  if (connect(fd, &s.sa, n) != 0 && errno != EINPROGRESS) {
+    int e = errno;
+    close(fd);
+    return nish_net_err(e);
+  }
+  return fd;
+}
+
+/* `connectResult(fd)`: how the connection `tcpConnect` started went, once the
+   descriptor is writable: 0 when it is made, or its failure (-111 refused,
+   -110 timed out) from `SO_ERROR`. The kernel clears `SO_ERROR` as it is
+   read, so a failure is answered once. */
+int32_t nish_connect_result(int32_t fd) {
+  int e = 0;
+  socklen_t n = sizeof e;
+  if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &e, &n) != 0) return nish_net_fail();
+  return e != 0 ? nish_net_err(e) : 0;
+}
+
 /* `netRead(fd, buf, off, len)`: at most `len` bytes into `buf` from `off`.
    The compiled call has already checked `0 <= off <= off + len <=
    buf.length`, unless the program was built with `--unchecked-indexing`. */
@@ -390,7 +435,9 @@ int32_t nish_udp_recv_from(int32_t fd, nish_array *buf, int64_t off, int64_t len
       .msg_name = &s, .msg_namelen = sizeof s, .msg_iov = &iov, .msg_iovlen = 1, .msg_control = c.b, .msg_controllen = sizeof c};
   ssize_t got = recvmsg(fd, &m, 0);
   if (got < 0) return nish_net_fail();
-  /* Darwin sets neither option, so both stay 0 there. */
+  /* Darwin sets neither option, so both stay 0 there: a `meta[1]` that reads
+     as Not-ECT whatever arrived, which is why the -95 of a marked send, not
+     this, is how a program learns ECN is unsupported. */
   int32_t info[2] = {0, 0};
 #if defined(__linux__)
   for (struct cmsghdr *h = CMSG_FIRSTHDR(&m); h != NULL; h = CMSG_NXTHDR(&m, h)) {

package/runtime/runtime-os.c

@@ -34,6 +34,7 @@
    the LEGACY symbol, for which a NULL second argument is undefined. */
 #define _XOPEN_SOURCE 700
 #include <dirent.h>
+#include <errno.h>
 #include <limits.h>
 #include <fcntl.h>
 #include <stdint.h>
@@ -59,6 +60,11 @@ extern char **environ;
 #if defined(__APPLE__) && !defined(O_NOFOLLOW)
 #define O_NOFOLLOW 0x00000100
 #endif
+/* `O_CLOEXEC` is POSIX 2008 and declared at that level everywhere; the
+   fallback is for an older Darwin SDK, with its value from the same header. */
+#if defined(__APPLE__) && !defined(O_CLOEXEC)
+#define O_CLOEXEC 0x01000000
+#endif
 
 /* The same spelling runtime.c uses for its own cold paths: a function that
    reports and exits is never on a path worth optimising for. */
@@ -96,9 +102,16 @@ static NISH_COLD void nish_io_fail(const char *what, const nish_str *path) {
  * narrower guard would have made it `null` here and split the two compilers
  * again for the entry a command line can name. `fstat` on the descriptor
  * rather than `stat` on the path, so the answer is about the file that was
- * opened and not about whatever the name means a moment later. */
+ * opened and not about whatever the name means a moment later.
+ *
+ * The descriptor is `O_CLOEXEC` (docs/security/runtime.md, RT-12): a child
+ * that a `scope()` task spawns while another task reads would otherwise
+ * inherit it. A `pread` that a signal interrupts before it moves a byte is
+ * retried rather than taken for the end of the file (RT-13). A local disk
+ * never interrupts one, but FUSE and NFS can, and stopping there would hand
+ * back the bytes so far as the whole file. */
 nish_str *nish_read_file_or_null(const nish_str *path) {
-  int fd = open(nish_cpath(path), O_RDONLY);
+  int fd = open(nish_cpath(path), O_RDONLY | O_CLOEXEC);
   if (fd < 0) return 0;
   struct stat st;
   off_t len = fstat(fd, &st) == 0 && !S_ISDIR(st.st_mode) ? lseek(fd, 0, SEEK_END) : -1;
@@ -114,7 +127,13 @@ nish_str *nish_read_file_or_null(const nish_str *path) {
   nish_str *s = nish_alloc_struct(8 + len + 1);
   uint64_t got = 0;
   ssize_t n;
-  while ((n = pread(fd, s->data + got, len - got, got)) > 0) got += n;
+  while ((n = pread(fd, s->data + got, len - got, got)) != 0) {
+    if (n > 0) {
+      got += n;
+    } else if (errno != EINTR) {
+      break;
+    }
+  }
   close(fd);
   s->len = got;
   s->data[got] = 0;
@@ -147,14 +166,21 @@ nish_str *nish_read_file(const nish_str *path) {
    followed to whatever file it names. `nish file.ts` writes `file.ll` beside
    its source, so a link planted at that name in a checkout would otherwise
    truncate any file the user can write. A link among the directories on the
-   way is still followed. */
+   way is still followed.
+
+   `O_CLOEXEC` for the reason the read has it (RT-12), and `EINTR` is retried
+   as the read retries it (RT-13): a write cut short is finished, and one that
+   fails is `cannot write`, never a silently short file. */
 static void nish_put_file(const nish_str *path, const nish_str *data, int flags) {
-  int fd = open(nish_cpath(path), O_WRONLY | O_CREAT | O_NOFOLLOW | flags, 0644);
+  int fd = open(nish_cpath(path), O_WRONLY | O_CREAT | O_NOFOLLOW | O_CLOEXEC | flags, 0644);
   if (fd < 0) nish_io_fail("write ", path);
   for (uint64_t done = 0; done < data->len;) {
     ssize_t n = write(fd, data->data + done, data->len - done);
-    if (n <= 0) nish_io_fail("write ", path);
-    done += n;
+    if (n > 0) {
+      done += n;
+    } else if (n == 0 || errno != EINTR) {
+      nish_io_fail("write ", path);
+    }
   }
   close(fd);
 }
@@ -214,24 +240,22 @@ static int32_t nish_spawn_impl(const nish_array *argv, const nish_str *out, cons
     if (v[i] != s[i]->data) return -1;
   }
   v[i] = 0;
+  /* One list of file actions whether or not a stream is redirected: an empty
+     list is the same spawn as none, and one path through is less code than
+     creating the list only when a stream needs it. */
   posix_spawn_file_actions_t fa;
-  posix_spawn_file_actions_t *fap = 0;
+  if (posix_spawn_file_actions_init(&fa)) return -1;
   const nish_str *to[2] = { out, err };
   for (int k = 0; k < 2; k++) {
-    if (!to[k]) continue;
-    if (!fap) {
-      if (posix_spawn_file_actions_init(&fa)) return -1;
-      fap = &fa;
-    }
     /* The child opens the file, not this process: a redirect that this process
        performed would have to be undone afterwards, and a failed open would
        leave its own stdout pointing at the file. */
-    posix_spawn_file_actions_addopen(fap, k + 1, nish_cpath(to[k]), O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0644);
+    if (to[k]) posix_spawn_file_actions_addopen(&fa, k + 1, nish_cpath(to[k]), O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0644);
   }
   pid_t pid;
   int status;
-  int failed = posix_spawnp(&pid, v[0], fap, 0, v, environ);
-  if (fap) posix_spawn_file_actions_destroy(fap);
+  int failed = posix_spawnp(&pid, v[0], &fa, 0, v, environ);
+  posix_spawn_file_actions_destroy(&fa);
   if (failed) return -1;
   if (waitpid(pid, &status, 0) < 0) return -1;
   return WIFSIGNALED(status) ? 128 + WTERMSIG(status) : WEXITSTATUS(status);
@@ -329,6 +353,10 @@ int64_t nish_monotonic_nanos(void) {
   return (int64_t)ts.tv_sec * 1000000000 + ts.tv_nsec;
 }
 
+/* A C string copied into the arena, or NULL for NULL: the shape of every
+   answer libc hands back by pointer, `getenv`'s here and `realpath`'s below. */
+static nish_str *nish_str_or_null(const char *v) { return v ? nish_str_new(v, strlen(v)) : 0; }
+
 /* ---- The environment (WP19 R1): `getenv(name)`, the one environment read the
    language has. A driver needs it to honour `CC` the way `scripts/build.sh`
    does before it spawns that script, which is the whole reason it exists.
@@ -340,8 +368,7 @@ int64_t nish_monotonic_nanos(void) {
    string with the lifetime every other one has. NULL for an unset variable,
    which is the language's `string | null`. Contract: nish.h. */
 nish_str *nish_getenv(const nish_str *name) {
-  const char *v = getenv(nish_cpath(name));
-  return v ? nish_str_new(v, strlen(v)) : 0;
+  return nish_str_or_null(getenv(nish_cpath(name)));
 }
 
 /* ---- Symlinks (WP19 §5a item 4): `realpathSync(path)`, the one path
@@ -363,10 +390,25 @@ nish_str *nish_getenv(const nish_str *name) {
    and the stack buffer is gone at the return. NULL when the path does not
    resolve -- a path that does not exist included -- which is the language's
    `string | null` rather than an error, because the caller is asking whether
-   it resolves. Contract: nish.h. */
+   it resolves. Contract: nish.h.
+
+   A wasi-libc from before 2024, which is what Ubuntu and Debian package,
+   neither declares nor defines `realpath`, so there every path is one that
+   does not resolve and the answer is NULL. WebAssembly/wasi-libc#463 declared
+   it and #473 defined it a month later, with no wasi-sdk release between, and
+   #463 also gave `<dirent.h>` its `DT_SOCK`, which the old headers spell only
+   for upstream musl. So a missing `DT_SOCK` is the test: it names the libc
+   without the function, and wasi-sdk 22 and later keep the real `realpath`.
+   It is a preprocessor test rather than a declaration of our own because the
+   old libc.a has no definition to link. */
 nish_str *nish_realpath(const nish_str *path) {
+#if defined(__wasi__) && !defined(DT_SOCK)
+  (void)path;
+  return 0;
+#else
   char buf[PATH_MAX];
-  return realpath(nish_cpath(path), buf) ? nish_str_new(buf, strlen(buf)) : 0;
+  return nish_str_or_null(realpath(nish_cpath(path), buf));
+#endif
 }
 
 /* ---- What machine this is (WP14 §7a): `process.platform` and `process.arch`,

package/runtime/runtime-simd.c

@@ -0,0 +1,203 @@
+/* Nish runtime, the vector half: byte searches that read sixteen or thirty-two
+ * bytes at a time (WP38 S1, docs/wp38-simd.md §3.1).
+ *
+ * A translation unit of its own for the reason runtime-host.c is one: each file
+ * carries its own measured `.text*` ceiling in tests/run.js, and runtime.c had
+ * no room left when this arrived. Section GC means a program that never calls a
+ * kernel links none of this file, and scripts/build.sh pairs it with runtime.c
+ * like the other halves, so a link line still names one runtime.
+ *
+ * Every kernel has up to three paths. The scalar one runs anywhere. The base
+ * one uses the vectors every machine of the target has -- SSE2 on x86-64, NEON
+ * on AArch64, simd128 on wasm only when built with `-msimd128`, which is not
+ * the default (wp38 §5) -- so it needs no question asked of the CPU. The AVX2
+ * one is compiled for that extension alone with `target("avx2")`, so the binary
+ * stays a baseline binary and only a machine that has it ever runs it.
+ *
+ * Which path runs is decided on a kernel's first call, never at program start.
+ * The kernel is called through a pointer that starts at its resolver; the
+ * resolver asks the CPU, stores the path it picked and calls it, and every
+ * later call goes straight to the stored path. `NISH_SIMD` pins the choice:
+ * `scalar` and `base` name their paths, and `avx2`, any other value, or no
+ * value at all mean the best this machine has. A machine without AVX2 that is
+ * asked for it gets the base path, because running it would fault. The
+ * instruction gate sets `NISH_SIMD=base` (bench/run.mjs) so that a count does
+ * not depend on the host it was measured on.
+ */
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "nish.h"
+
+#if defined(__x86_64__) || defined(__i386__)
+#if defined(__SSE2__)
+#include <cpuid.h>
+#include <immintrin.h>
+#define NISH_SIMD_SSE2 1
+#endif
+#elif defined(__ARM_NEON)
+#include <arm_neon.h>
+#define NISH_SIMD_NEON 1
+#elif defined(__wasm_simd128__)
+#include <wasm_simd128.h>
+#define NISH_SIMD_WASM 1
+#endif
+
+/* One path of `nish_str_index_of_any`: the contract in nish.h. */
+typedef int64_t (*nish_any_path)(const nish_str *s, const nish_str *set, int64_t from);
+
+/* The scalar path, and the tail of the vector ones. A 256-bit membership
+   table answers each byte with one load and one shift whatever the size of
+   the set, so this path is also total: an empty set finds nothing and a set
+   longer than sixteen bytes is answered correctly, which is why the vector
+   paths hand any set outside 1..16 bytes to it rather than overrun their
+   sixteen splatted registers. */
+static int64_t nish_any_scalar(const nish_str *s, const nish_str *set, int64_t from) {
+  uint32_t in[8] = {0};
+  for (uint64_t k = 0; k < set->len; k++) {
+    uint8_t b = (uint8_t)set->data[k];
+    in[b >> 5] |= 1u << (b & 31);
+  }
+  for (uint64_t i = (uint64_t)from; i < s->len; i++) {
+    uint8_t b = (uint8_t)s->data[i];
+    if (in[b >> 5] >> (b & 31) & 1) return (int64_t)i;
+  }
+  return -1;
+}
+
+/* The vector paths compare each block against every byte of the set and OR
+   the answers, rather than classify each byte by its two nibbles through a
+   shuffle table as simdjson does. The shuffle is `pshufb`, which is SSSE3 and
+   not in the x86-64 baseline, and a two-table classify is only exact for a
+   set whose bytes fit eight nibble classes; an arbitrary set of sixteen bytes
+   does not. A compare per set byte is exact for every set, and the sets this
+   was built for -- a quote and a backslash, JSON's six structural bytes -- are
+   small enough that the compares cost less than the shuffles would. */
+#if defined(NISH_SIMD_SSE2)
+static int64_t nish_any_base(const nish_str *s, const nish_str *set, int64_t from) {
+  uint64_t k = set->len, n = s->len, i = (uint64_t)from;
+  if (k - 1 >= 16) return nish_any_scalar(s, set, from);
+  __m128i want[16];
+  for (uint64_t j = 0; j < k; j++) want[j] = _mm_set1_epi8(set->data[j]);
+  for (; i + 16 <= n; i += 16) {
+    __m128i v = _mm_loadu_si128((const __m128i *)(s->data + i));
+    __m128i hit = _mm_cmpeq_epi8(v, want[0]);
+    for (uint64_t j = 1; j < k; j++) hit = _mm_or_si128(hit, _mm_cmpeq_epi8(v, want[j]));
+    unsigned m = (unsigned)_mm_movemask_epi8(hit);
+    if (m) return (int64_t)(i + (uint64_t)__builtin_ctz(m));
+  }
+  return nish_any_scalar(s, set, (int64_t)i);
+}
+
+/* Thirty-two bytes a block, then the base path for what is left: a tail of
+   up to thirty-one bytes is at most one sixteen-byte block and a scalar run. */
+__attribute__((target("avx2"))) static int64_t nish_any_avx2(const nish_str *s, const nish_str *set,
+                                                             int64_t from) {
+  uint64_t k = set->len, n = s->len, i = (uint64_t)from;
+  if (k - 1 >= 16) return nish_any_scalar(s, set, from);
+  __m256i want[16];
+  for (uint64_t j = 0; j < k; j++) want[j] = _mm256_set1_epi8(set->data[j]);
+  for (; i + 32 <= n; i += 32) {
+    __m256i v = _mm256_loadu_si256((const __m256i *)(s->data + i));
+    __m256i hit = _mm256_cmpeq_epi8(v, want[0]);
+    for (uint64_t j = 1; j < k; j++) hit = _mm256_or_si256(hit, _mm256_cmpeq_epi8(v, want[j]));
+    unsigned m = (unsigned)_mm256_movemask_epi8(hit);
+    if (m) return (int64_t)(i + (uint64_t)__builtin_ctz(m));
+  }
+  return nish_any_base(s, set, (int64_t)i);
+}
+#elif defined(NISH_SIMD_NEON)
+static int64_t nish_any_base(const nish_str *s, const nish_str *set, int64_t from) {
+  uint64_t k = set->len, n = s->len, i = (uint64_t)from;
+  if (k - 1 >= 16) return nish_any_scalar(s, set, from);
+  uint8x16_t want[16];
+  for (uint64_t j = 0; j < k; j++) want[j] = vdupq_n_u8((uint8_t)set->data[j]);
+  for (; i + 16 <= n; i += 16) {
+    uint8x16_t v = vld1q_u8((const uint8_t *)s->data + i);
+    uint8x16_t hit = vceqq_u8(v, want[0]);
+    for (uint64_t j = 1; j < k; j++) hit = vorrq_u8(hit, vceqq_u8(v, want[j]));
+    /* NEON has no movemask. Shifting each 16-bit pair of answers right by four
+       and narrowing keeps four bits of every byte's answer, in order, in one
+       64-bit lane, so the first hit is the lowest set bit over four. The
+       idea is Danila Kutenin's ("Porting x86 vector bitmask optimizations to
+       Arm NEON", Arm Community blog, 2022). */
+    uint64_t m = vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(hit), 4)), 0);
+    if (m) return (int64_t)(i + ((uint64_t)__builtin_ctzll(m) >> 2));
+  }
+  return nish_any_scalar(s, set, (int64_t)i);
+}
+#elif defined(NISH_SIMD_WASM)
+static int64_t nish_any_base(const nish_str *s, const nish_str *set, int64_t from) {
+  uint64_t k = set->len, n = s->len, i = (uint64_t)from;
+  if (k - 1 >= 16) return nish_any_scalar(s, set, from);
+  v128_t want[16];
+  for (uint64_t j = 0; j < k; j++) want[j] = wasm_i8x16_splat(set->data[j]);
+  for (; i + 16 <= n; i += 16) {
+    v128_t v = wasm_v128_load(s->data + i);
+    v128_t hit = wasm_i8x16_eq(v, want[0]);
+    for (uint64_t j = 1; j < k; j++) hit = wasm_v128_or(hit, wasm_i8x16_eq(v, want[j]));
+    uint32_t m = wasm_i8x16_bitmask(hit);
+    if (m) return (int64_t)(i + (uint64_t)__builtin_ctz(m));
+  }
+  return nish_any_scalar(s, set, (int64_t)i);
+}
+#else
+/* A target with no vectors in its baseline: wasm without `-msimd128`, the
+   default there, among them. Its base path is the scalar one. */
+#define nish_any_base nish_any_scalar
+#endif
+
+#if defined(NISH_SIMD_SSE2)
+/* Whether this machine runs AVX2 code: the CPU has the extension (leaf 7,
+   EBX bit 5) and the operating system saves the 256-bit registers across a
+   context switch (OSXSAVE, then XCR0's SSE and AVX bits): the procedure the
+   Intel SDM gives for detecting AVX2, and the three facts
+   `__builtin_cpu_supports("avx2")` reads. That builtin is not used,
+   because its answer lives in libgcc's `__cpu_model`, and the object that
+   defines it carries a constructor that fills it in at start-up: once a link
+   names it, every program pays, a kernel called or not. Measured on
+   `examples/hello.ts` at `--profile speed`, that object took the binary from
+   4,712 bytes to 10,000 and the run 374 instructions longer. `cpuid.h` is inline
+   assembly and nothing else, so here the question is asked on the first call
+   and never before it. */
+static int nish_cpu_has_avx2(void) {
+  unsigned a, b, c, d;
+  if (!__get_cpuid(1, &a, &b, &c, &d) || !(c & bit_OSXSAVE) || !(c & bit_AVX)) return 0;
+  unsigned lo, hi;
+  __asm__("xgetbv" : "=a"(lo), "=d"(hi) : "c"(0));
+  if ((lo & 6) != 6) return 0;
+  return __get_cpuid_count(7, 0, &a, &b, &c, &d) && (b & bit_AVX2);
+}
+#endif
+
+/* Which path `NISH_SIMD` and this machine pick. AVX2 is asked of the CPU only
+   when the answer could matter, so a pinned `scalar` or `base` never reads
+   the CPU's feature bits at all. */
+static nish_any_path nish_any_choose(void) {
+  const char *pin = getenv("NISH_SIMD");
+  if (pin != NULL && strcmp(pin, "scalar") == 0) return nish_any_scalar;
+  if (pin != NULL && strcmp(pin, "base") == 0) return nish_any_base;
+#if defined(NISH_SIMD_SSE2)
+  if (nish_cpu_has_avx2()) return nish_any_avx2;
+#endif
+  return nish_any_base;
+}
+
+static int64_t nish_any_resolve(const nish_str *s, const nish_str *set, int64_t from);
+
+/* The path every call goes through, the resolver until the first call has
+   run. The loads and the store are relaxed atomics, which are plain moves on
+   every target, because under `--threads` two workers may make the first call
+   at once; both pick the same path, so whichever store lands is the answer. */
+static nish_any_path nish_any = nish_any_resolve;
+
+static int64_t nish_any_resolve(const nish_str *s, const nish_str *set, int64_t from) {
+  nish_any_path path = nish_any_choose();
+  __atomic_store_n(&nish_any, path, __ATOMIC_RELAXED);
+  return path(s, set, from);
+}
+
+int64_t nish_str_index_of_any(const nish_str *s, const nish_str *set, int64_t from) {
+  return __atomic_load_n(&nish_any, __ATOMIC_RELAXED)(s, set, from);
+}

package/runtime/runtime-wasm.c

@@ -115,10 +115,22 @@ void nish_array_grow(nish_array *a, uint64_t elem_size) {
   a->cap = cap;
 }
 
+/* ---- Math.min and Math.max of a float: llvm.minnum / llvm.maxnum, which wasm32
+ * has no instruction for. Its `f64.min` answers NaN when either operand is NaN,
+ * and minnum answers the other operand, so the backend lowers minnum to a libm
+ * call, and these are that libm. They answer what minnum answers natively: a
+ * NaN operand is dropped, and two NaNs give NaN (tests/cases/math_minmax_float,
+ * held to these by tests/run.js). Between `0` and `-0` minnum may answer either. */
+double fmin(double a, double b) { return a != a ? b : b != b ? a : a < b ? a : b; }
+double fmax(double a, double b) { return a != a ? b : b != b ? a : a > b ? a : b; }
+float fminf(float a, float b) { return a != a ? b : b != b ? a : a < b ? a : b; }
+float fmaxf(float a, float b) { return a != a ? b : b != b ? a : a > b ? a : b; }
+
 /* ---- Panics: `unreachable`, which the host sees as a RuntimeError */
 void nish_panic_index(uint64_t idx, uint64_t len) { (void)idx; (void)len; __builtin_trap(); }
 void nish_panic_slice(int64_t s, int64_t e, int64_t len) { (void)s; (void)e; (void)len; __builtin_trap(); }
 void nish_panic_div(_Bool by_zero) { (void)by_zero; __builtin_trap(); }
+void nish_panic_overflow(uint32_t op) { (void)op; __builtin_trap(); }
 void nish_exit(int32_t code) { (void)code; __builtin_trap(); }
 /* A panic's message (`panic`, `expect`, a failed range entry) has no stderr to
  * go to here; the `nish_exit` that follows it is the trap. An exported function