Less SIMD.

Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.38.0 to 0.39.0.
- [Commits](https://github.com/golang/crypto/compare/v0.38.0...v0.39.0)

---
updated-dependencies:
- dependency-name: golang.org/x/crypto
  dependency-version: 0.39.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/test.yml

@@ -112,7 +112,7 @@ jobs:
             version: '10.1'
             flags: '-test.v -test.short'
           - name: openbsd
-            version: '7.6'
+            version: '7.7'
             flags: '-test.v -test.short'
     runs-on: ubuntu-latest
     needs: test
@@ -128,7 +128,7 @@ jobs:
       run: .github/workflows/build-test.sh
 
     - name: Test
-      uses: cross-platform-actions/action@v0.27.0
+      uses: cross-platform-actions/action@v0.28.0
       with:
         operating_system: ${{ matrix.os.name }}
         architecture: ${{ matrix.os.arch }}

README.md

@@ -30,10 +30,10 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 
 - [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
   wraps the [C SQLite API](https://sqlite.org/cintro.html)
-  ([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
 - [`github.com/ncruces/go-sqlite3/driver`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver)
   provides a [`database/sql`](https://pkg.go.dev/database/sql) driver
-  ([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
 - [`github.com/ncruces/go-sqlite3/embed`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/embed)
   embeds a build of SQLite into your application.
 - [`github.com/ncruces/go-sqlite3/vfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs)
@@ -44,12 +44,19 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 ### Advanced features
 
 - [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blobio#example-package))
 - [nested transactions](https://sqlite.org/lang_savepoint.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-Savepoint))
 - [custom functions](https://sqlite.org/c3ref/create_function.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-Conn.CreateFunction))
 - [virtual tables](https://sqlite.org/vtab.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-CreateModule))
 - [custom VFSes](https://sqlite.org/vfs.html)
+  ([examples](vfs/README.md#custom-vfses))
 - [online backup](https://sqlite.org/backup.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#Conn))
 - [JSON support](https://sqlite.org/json1.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package-Json))
 - [math functions](https://sqlite.org/lang_mathfunc.html)
 - [full-text search](https://sqlite.org/fts5.html)
 - [geospatial search](https://sqlite.org/geopoly.html)
@@ -57,7 +64,6 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 - [statistics functions](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
 - [encryption at rest](vfs/adiantum/README.md)
 - [many extensions](ext/README.md)
-- [custom VFSes](vfs/README.md#custom-vfses)
 - [and more…](embed/README.md)
 
 ### Caveats
@@ -77,10 +83,19 @@ It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
 [wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach)
 thorough testing.
 
-Every commit is [tested](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix) on
-Linux (amd64/arm64/386/riscv64/ppc64le/s390x), macOS (arm64/amd64),
-Windows (amd64), FreeBSD (amd64/arm64), OpenBSD (amd64), NetBSD (amd64/arm64),
-DragonFly BSD (amd64), illumos (amd64), and Solaris (amd64).
+Every commit is tested on:
+* Linux: amd64, arm64, 386, riscv64, ppc64le, s390x
+* macOS: amd64, arm64
+* Windows: amd64
+* BSD:
+  * FreeBSD: amd64, arm64
+  * OpenBSD: amd64
+  * NetBSD: amd64, arm64
+  * DragonFly BSD: amd64
+* illumos: amd64
+* Solaris: amd64
+
+Certain operating system and CPU combinations have some limitations. See the [support matrix](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix) for a complete overview.
 
 The Go VFS is tested by running SQLite's
 [mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).
@@ -118,4 +133,4 @@ and features we're working on, planning to work on, or asking for help with.
 - [`modernc.org/sqlite`](https://pkg.go.dev/modernc.org/sqlite)
 - [`crawshaw.io/sqlite`](https://pkg.go.dev/crawshaw.io/sqlite)
 - [`github.com/mattn/go-sqlite3`](https://pkg.go.dev/github.com/mattn/go-sqlite3)
-- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)
+- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)

config.go

@@ -109,7 +109,7 @@ func (c *Conn) FileControl(schema string, op FcntlOpcode, arg ...any) (any, erro
 	default:
 		return nil, MISUSE
 
-	case FCNTL_RESET_CACHE:
+	case FCNTL_RESET_CACHE, FCNTL_NULL_IO:
 		rc = res_t(c.call("sqlite3_file_control",
 			stk_t(c.handle), stk_t(schemaPtr),
 			stk_t(op), 0))

const.go

@@ -280,6 +280,7 @@ const (
 	FCNTL_DATA_VERSION        FcntlOpcode = 35
 	FCNTL_RESERVE_BYTES       FcntlOpcode = 38
 	FCNTL_RESET_CACHE         FcntlOpcode = 42
+	FCNTL_NULL_IO             FcntlOpcode = 43
 )
 
 // LimitCategory are the available run-time limit categories.

context.go

@@ -177,12 +177,15 @@ func (ctx Context) ResultPointer(ptr any) {
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultJSON(value any) {
-	data, err := json.Marshal(value)
+	err := json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
+		ctx.ResultRawText(p[:len(p)-1]) // remove the newline
+		return 0, nil
+	})).Encode(value)
+
 	if err != nil {
 		ctx.ResultError(err)
 		return // notest
 	}
-	ctx.ResultRawText(data)
 }
 
 // ResultValue sets the result of the function to a copy of [Value].

embed/README.md

@@ -1,6 +1,6 @@
 # Embeddable Wasm build of SQLite
 
-This folder includes an embeddable Wasm build of SQLite 3.49.1 for use with
+This folder includes an embeddable Wasm build of SQLite 3.50.1 for use with
 [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3).
 
 The following optional features are compiled in:

embed/bcw2/bcw2_test.go

@@ -53,7 +53,7 @@ func Test_bcw2(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if version != "3.50.0" {
+	if version != "3.51.0" {
 		t.Error(version)
 	}
 }

embed/bcw2/build.sh

@@ -13,8 +13,8 @@ mkdir -p build/ext/
 cp "$ROOT"/sqlite3/*.[ch] build/
 cp "$ROOT"/sqlite3/*.patch build/
 
-# https://sqlite.org/src/info/3215186aa9204149
-curl -# https://sqlite.org/src/tarball/sqlite.tar.gz?r=3215186a | tar xz
+# https://sqlite.org/src/info/93740658c8c6f531
+curl -# https://sqlite.org/src/tarball/sqlite.tar.gz?r=93740658c8 | tar xz
 
 cd sqlite
 if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
@@ -43,12 +43,12 @@ cd ~-
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
-	-o bcw2.wasm "build/main.c" \
-	-I"build" \
+	-o bcw2.wasm build/main.c \
+	-I"$ROOT/sqlite3/libc" -I"build" \
 	-mexec-model=reactor \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -61,6 +61,6 @@ cd ~-
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize bcw2.wasm -o bcw2.tmp
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
 	bcw2.tmp -o bcw2.wasm --low-memory-unused \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue

embed/bcw2/go.mod

@@ -4,11 +4,11 @@ go 1.23.0
 
 toolchain go1.24.0
 
-require github.com/ncruces/go-sqlite3 v0.25.0
+require github.com/ncruces/go-sqlite3 v0.26.0
 
 require (
 	github.com/ncruces/julianday v1.0.0 // indirect
 	github.com/ncruces/sort v0.1.5 // indirect
 	github.com/tetratelabs/wazero v1.9.0 // indirect
-	golang.org/x/sys v0.32.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
 )

embed/bcw2/go.sum

@@ -1,12 +1,12 @@
-github.com/ncruces/go-sqlite3 v0.25.0 h1:trugKUs98Zwy9KwRr/EUxZHL92LYt7UqcKqAfpGpK+I=
-github.com/ncruces/go-sqlite3 v0.25.0/go.mod h1:n6Z7036yFilJx04yV0mi5JWaF66rUmXn1It9Ux8dx68=
+github.com/ncruces/go-sqlite3 v0.26.0 h1:dY6ASfuhSEbtSge6kJwjyJVC7bXCpgEVOycmdboKJek=
+github.com/ncruces/go-sqlite3 v0.26.0/go.mod h1:46HIzeCQQ+aNleAxCli+vpA2tfh7ttSnw24kQahBc1o=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/ncruces/sort v0.1.5 h1:fiFWXXAqKI8QckPf/6hu/bGFwcEPrirIOFaJqWujs4k=
 github.com/ncruces/sort v0.1.5/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
 github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
 github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
-golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=

embed/build.sh

@@ -14,9 +14,9 @@ trap 'rm -f sqlite3.tmp' EXIT
 	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
 	-I"$ROOT/sqlite3/libc" -I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -28,6 +28,6 @@ trap 'rm -f sqlite3.tmp' EXIT
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
 	sqlite3.tmp -o sqlite3.wasm --low-memory-unused \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue

embed/init_test.go

@@ -19,7 +19,7 @@ func Test_init(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if version != "3.49.1" {
+	if version != "3.50.1" {
 		t.Error(version)
 	}
 }

ext/README.md

@@ -30,7 +30,7 @@ you can load into your database connections.
 - [`github.com/ncruces/go-sqlite3/ext/statement`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/statement)
   creates [parameterized views](https://github.com/0x09/sqlite-statement-vtab).
 - [`github.com/ncruces/go-sqlite3/ext/stats`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
-  provides [statistics](https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html) functions.
+  provides [statistics](https://oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html) functions.
 - [`github.com/ncruces/go-sqlite3/ext/unicode`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/unicode)
   provides [Unicode aware](https://sqlite.org/src/dir/ext/icu) functions.
 - [`github.com/ncruces/go-sqlite3/ext/uuid`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/uuid)

ext/blobio/blob_test.go

@@ -1,6 +1,7 @@
 package blobio_test
 
 import (
+	"database/sql"
 	"io"
 	"log"
 	"os"
@@ -34,7 +35,8 @@ func Example() {
 	const message = "Hello BLOB!"
 
 	// Create the BLOB.
-	r, err := db.Exec(`INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(len(message)))
+	r, err := db.Exec(`INSERT INTO test VALUES (:data)`,
+		sql.Named("data", sqlite3.ZeroBlob(len(message))))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -45,15 +47,19 @@ func Example() {
 	}
 
 	// Write the BLOB.
-	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', ?, 0, ?)`,
-		id, message)
+	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', :rowid, :offset, :message)`,
+		sql.Named("rowid", id),
+		sql.Named("offset", 0),
+		sql.Named("message", message))
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Read the BLOB.
-	_, err = db.Exec(`SELECT readblob('main', 'test', 'col', ?, 0, ?)`,
-		id, sqlite3.Pointer(os.Stdout))
+	_, err = db.Exec(`SELECT readblob('main', 'test', 'col', :rowid, :offset, :writer)`,
+		sql.Named("rowid", id),
+		sql.Named("offset", 0),
+		sql.Named("writer", sqlite3.Pointer(os.Stdout)))
 	if err != nil {
 		log.Fatal(err)
 	}

ext/regexp/regexp_test.go

@@ -38,7 +38,7 @@ func TestRegister(t *testing.T) {
 		{`regexp_instr('Hello', '.', 6)`, ""},
 		{`regexp_substr('Hello', 'el.')`, "ell"},
 		{`regexp_replace('Hello', 'llo', 'll')`, "Hell"},
-		// https://www.postgresql.org/docs/current/functions-matching.html
+		// https://postgresql.org/docs/current/functions-matching.html
 		{`regexp_count('ABCABCAXYaxy', 'A.')`, "3"},
 		{`regexp_count('ABCABCAXYaxy', '(?i)A.', 1)`, "4"},
 		{`regexp_instr('number of your street, town zip, FR', '[^,]+', 1, 2)`, "23"},

ext/stats/TODO.md

@@ -1,6 +1,6 @@
 # ANSI SQL Aggregate Functions
 
-https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html
+https://oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html
 
 ## Built in aggregates
 

ext/stats/stats.go

@@ -47,7 +47,7 @@
 //
 // [Built-in Aggregate Functions]: https://sqlite.org/lang_aggfunc.html
 // [Built-in Window Functions]: https://sqlite.org/windowfunctions.html#builtins
-// [ANSI SQL Aggregate Functions]: https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html
+// [ANSI SQL Aggregate Functions]: https://oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html
 package stats
 
 import (

go.mod

@@ -8,16 +8,16 @@ require (
 	github.com/ncruces/julianday v1.0.0
 	github.com/ncruces/sort v0.1.5
 	github.com/tetratelabs/wazero v1.9.0
-	golang.org/x/crypto v0.37.0
-	golang.org/x/sys v0.32.0
+	golang.org/x/crypto v0.39.0
+	golang.org/x/sys v0.33.0
 )
 
 require (
 	github.com/dchest/siphash v1.2.3 // ext/bloom
 	github.com/google/uuid v1.6.0 // ext/uuid
 	github.com/psanford/httpreadat v0.1.0 // example
-	golang.org/x/sync v0.13.0 // test
-	golang.org/x/text v0.24.0 // ext/unicode
+	golang.org/x/sync v0.15.0 // test
+	golang.org/x/text v0.26.0 // ext/unicode
 	lukechampine.com/adiantum v1.1.1 // vfs/adiantum
 )
 

go.sum

@@ -10,13 +10,13 @@ github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIw
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
 github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
 github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
-golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
-golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
-golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
-golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
-golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
+golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
+golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
+golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
+golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=
 lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

gormlite/ddlmod.go

@@ -209,8 +209,12 @@ func (d *ddl) renameTable(dst, src string) error {
 	return nil
 }
 
+func compileConstraintRegexp(name string) *regexp.Regexp {
+	return regexp.MustCompile("^(?i:CONSTRAINT)\\s+[\"`]?" + regexp.QuoteMeta(name) + "[\"`\\s]")
+}
+
 func (d *ddl) addConstraint(name string, sql string) {
-	reg := regexp.MustCompile("^CONSTRAINT [\"`]?" + regexp.QuoteMeta(name) + "[\"` ]")
+	reg := compileConstraintRegexp(name)
 
 	for i := 0; i < len(d.fields); i++ {
 		if reg.MatchString(d.fields[i]) {
@@ -223,7 +227,7 @@ func (d *ddl) addConstraint(name string, sql string) {
 }
 
 func (d *ddl) removeConstraint(name string) bool {
-	reg := regexp.MustCompile("^CONSTRAINT [\"`]?" + regexp.QuoteMeta(name) + "[\"` ]")
+	reg := compileConstraintRegexp(name)
 
 	for i := 0; i < len(d.fields); i++ {
 		if reg.MatchString(d.fields[i]) {
@@ -236,7 +240,7 @@ func (d *ddl) removeConstraint(name string) bool {
 
 //lint:ignore U1000 ignore unused code.
 func (d *ddl) hasConstraint(name string) bool {
-	reg := regexp.MustCompile("^CONSTRAINT [\"`]?" + regexp.QuoteMeta(name) + "[\"` ]")
+	reg := compileConstraintRegexp(name)
 
 	for _, f := range d.fields {
 		if reg.MatchString(f) {

gormlite/ddlmod_parse_all_columns.go

@@ -95,7 +95,7 @@ func parseAllColumns(in string) ([]string, error) {
 			}
 			return nil, fmt.Errorf("unexpected token: %s", string(s[i]))
 		case parseAllColumnsState_State_End:
-			break
+			continue // avoid SA4011
 		}
 	}
 	if state != parseAllColumnsState_State_End {

gormlite/ddlmod_test.go

@@ -313,6 +313,41 @@ func TestRemoveConstraint(t *testing.T) {
 			success: true,
 			expect:  []string{"`id` integer NOT NULL"},
 		},
+		{
+			name:    "lowercase",
+			fields:  []string{"`id` integer NOT NULL", "constraint `fk_users_notes` FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "mixed_case",
+			fields:  []string{"`id` integer NOT NULL", "cOnsTraiNT `fk_users_notes` FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "newline",
+			fields:  []string{"`id` integer NOT NULL", "CONSTRAINT `fk_users_notes`\nFOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "lots_of_newlines",
+			fields:  []string{"`id` integer NOT NULL", "constraint \n    fk_users_notes \n   FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "no_backtick",
+			fields:  []string{"`id` integer NOT NULL", "CONSTRAINT fk_users_notes FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
 		{
 			name:    "check",
 			fields:  []string{"CONSTRAINT `name_checker` CHECK (`name` <> 'thetadev')", "`id` integer NOT NULL"},

gormlite/go.mod

@@ -5,8 +5,8 @@ go 1.23.0
 toolchain go1.24.0
 
 require (
-	github.com/ncruces/go-sqlite3 v0.25.0
-	gorm.io/gorm v1.25.12
+	github.com/ncruces/go-sqlite3 v0.26.0
+	gorm.io/gorm v1.30.0
 )
 
 require (
@@ -14,6 +14,6 @@ require (
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
 	github.com/tetratelabs/wazero v1.9.0 // indirect
-	golang.org/x/sys v0.32.0 // indirect
-	golang.org/x/text v0.24.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/text v0.26.0 // indirect
 )

gormlite/go.sum

@@ -2,15 +2,15 @@ github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/ncruces/go-sqlite3 v0.25.0 h1:trugKUs98Zwy9KwRr/EUxZHL92LYt7UqcKqAfpGpK+I=
-github.com/ncruces/go-sqlite3 v0.25.0/go.mod h1:n6Z7036yFilJx04yV0mi5JWaF66rUmXn1It9Ux8dx68=
+github.com/ncruces/go-sqlite3 v0.26.0 h1:dY6ASfuhSEbtSge6kJwjyJVC7bXCpgEVOycmdboKJek=
+github.com/ncruces/go-sqlite3 v0.26.0/go.mod h1:46HIzeCQQ+aNleAxCli+vpA2tfh7ttSnw24kQahBc1o=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
 github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
-golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
-golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
-gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
-gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
+golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+gorm.io/gorm v1.30.0 h1:qbT5aPv1UH8gI99OsRlvDToLxW5zR7FzS9acZDOZcgs=
+gorm.io/gorm v1.30.0/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=

gormlite/sqlite.go

@@ -1,4 +1,3 @@
-// Package gormlite provides a GORM driver for SQLite.
 package gormlite
 
 import (
@@ -52,7 +51,9 @@ func (dialector _Dialector) Initialize(db *gorm.DB) (err error) {
 	})
 
 	for k, v := range dialector.ClauseBuilders() {
-		db.ClauseBuilders[k] = v
+		if _, ok := db.ClauseBuilders[k]; !ok {
+			db.ClauseBuilders[k] = v
+		}
 	}
 	return
 }

gormlite/test.sh

@@ -7,7 +7,7 @@ rm -rf gorm/ tests/
 go work use -r .
 go test
 
-git clone --branch v1.25.12 --filter=blob:none https://github.com/go-gorm/gorm.git
+git clone --branch v1.30.0 --filter=blob:none https://github.com/go-gorm/gorm.git
 mv gorm/tests tests
 rm -rf gorm/
 

gormlite/update.sh

@@ -3,13 +3,12 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/ddlmod.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/ddlmod_test.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/ddlmod_parse_all_columns.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/ddlmod_parse_all_columns_test.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/error_translator.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/migrator.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/sqlite.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/sqlite_test.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/sqlite_test.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.6.0/ddlmod.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.6.0/ddlmod_test.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.6.0/ddlmod_parse_all_columns.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.6.0/ddlmod_parse_all_columns_test.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.6.0/error_translator.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.6.0/migrator.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.6.0/sqlite.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.6.0/sqlite_test.go"
 curl -#L "https://github.com/glebarez/sqlite/raw/v1.11.0/sqlite_error_translator_test.go" > error_translator_test.go

sqlite3/busy_timeout.patch

@@ -2,7 +2,7 @@
 # handle, and interrupt, sqlite3_busy_timeout.
 --- sqlite3.c.orig
 +++ sqlite3.c
-@@ -183355,7 +183355,7 @@
+@@ -183364,7 +183364,7 @@
    if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
  #endif
    if( ms>0 ){

sqlite3/download.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://sqlite.org/2025/sqlite-amalgamation-3490100.zip"
+curl -#OL "https://sqlite.org/2025/sqlite-amalgamation-3500100.zip"
 unzip -d . sqlite-amalgamation-*.zip
 mv sqlite-amalgamation-*/sqlite3.c .
 mv sqlite-amalgamation-*/sqlite3.h .
@@ -19,30 +19,30 @@ rm -rf sqlite-amalgamation-*
 
 mkdir -p ext/
 cd ext/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/anycollseq.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/base64.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/decimal.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/ieee754.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/regexp.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/series.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/spellfix.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/uint.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/ext/misc/anycollseq.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/ext/misc/base64.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/ext/misc/decimal.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/ext/misc/ieee754.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/ext/misc/regexp.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/ext/misc/series.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/ext/misc/spellfix.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/ext/misc/uint.c"
 cd ~-
 
 cd ../vfs/tests/mptest/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/config01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/config02.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/crash01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/crash02.subtest"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/multiwrite01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/mptest/config01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/mptest/config02.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/mptest/crash01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/mptest/crash02.subtest"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/mptest/multiwrite01.test"
 cd ~-
 
 cd ../vfs/tests/mptest/wasm/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/mptest.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/mptest/mptest.c"
 cd ~-
 
 cd ../vfs/tests/speedtest1/wasm/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/test/speedtest1.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.1/test/speedtest1.c"
 cd ~-
 
 cat *.patch | patch -p0 --no-backup-if-mismatch

sqlite3/libc/build.sh

@@ -11,40 +11,42 @@ SRCS="${1:-libc.c}"
 
 trap 'rm -f libc.c libc.tmp' EXIT
 cat << EOF > libc.c
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
+#include <strings.h>
 EOF
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
 	-o libc.wasm -I. "$SRCS" \
 	-mexec-model=reactor \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
-	-Wl,-z,stack-size=1024 \
+	-Wl,-z,stack-size=4096 \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
 	-Wl,--initial-memory=16777216 \
 	-Wl,--export=memchr \
 	-Wl,--export=memcmp \
 	-Wl,--export=memcpy \
+	-Wl,--export=memmove \
+	-Wl,--export=memrchr \
 	-Wl,--export=memset \
 	-Wl,--export=strchr \
 	-Wl,--export=strchrnul \
-	-Wl,--export=strcmp \
 	-Wl,--export=strcspn \
 	-Wl,--export=strlen \
-	-Wl,--export=strncmp \
+	-Wl,--export=strrchr \
 	-Wl,--export=strspn \
 	-Wl,--export=qsort
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize libc.wasm -o libc.tmp
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
 	libc.tmp -o libc.wasm \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue
 
 "$BINARYEN/wasm-dis" -o libc.wat libc.wasm

sqlite3/libc/libc_test.go

@@ -1,10 +1,13 @@
 package libc
 
 import (
+	"bytes"
 	"context"
 	_ "embed"
 	"os"
+	"strings"
 	"testing"
+	"unicode/utf8"
 
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/api"
@@ -29,9 +32,8 @@ var (
 	memcmp  api.Function
 	strlen  api.Function
 	strchr  api.Function
-	strcmp  api.Function
 	strspn  api.Function
-	strncmp api.Function
+	strrchr api.Function
 	strcspn api.Function
 	stack   [8]uint64
 )
@@ -61,9 +63,8 @@ func TestMain(m *testing.M) {
 	memcmp = mod.ExportedFunction("memcmp")
 	strlen = mod.ExportedFunction("strlen")
 	strchr = mod.ExportedFunction("strchr")
-	strcmp = mod.ExportedFunction("strcmp")
 	strspn = mod.ExportedFunction("strspn")
-	strncmp = mod.ExportedFunction("strncmp")
+	strrchr = mod.ExportedFunction("strrchr")
 	strcspn = mod.ExportedFunction("strcspn")
 	memory, _ = mod.Memory().Read(0, mod.Memory().Size())
 
@@ -91,6 +92,17 @@ func Benchmark_memcpy(b *testing.B) {
 	}
 }
 
+func Benchmark_strlen(b *testing.B) {
+	clear(memory)
+	fill(memory[ptr1:ptr1+size-1], 5)
+
+	b.SetBytes(size)
+	b.ResetTimer()
+	for range b.N {
+		call(strlen, ptr1)
+	}
+}
+
 func Benchmark_memchr(b *testing.B) {
 	clear(memory)
 	fill(memory[ptr1:ptr1+size/2], 7)
@@ -103,30 +115,6 @@ func Benchmark_memchr(b *testing.B) {
 	}
 }
 
-func Benchmark_memcmp(b *testing.B) {
-	clear(memory)
-	fill(memory[ptr1:ptr1+size], 7)
-	fill(memory[ptr2:ptr2+size/2], 7)
-	fill(memory[ptr2+size/2:ptr2+size], 5)
-
-	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
-		call(memcmp, ptr1, ptr2, size)
-	}
-}
-
-func Benchmark_strlen(b *testing.B) {
-	clear(memory)
-	fill(memory[ptr1:ptr1+size-1], 5)
-
-	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
-		call(strlen, ptr1)
-	}
-}
-
 func Benchmark_strchr(b *testing.B) {
 	clear(memory)
 	fill(memory[ptr1:ptr1+size/2], 7)
@@ -139,29 +127,28 @@ func Benchmark_strchr(b *testing.B) {
 	}
 }
 
-func Benchmark_strcmp(b *testing.B) {
+func Benchmark_strrchr(b *testing.B) {
 	clear(memory)
-	fill(memory[ptr1:ptr1+size-1], 7)
-	fill(memory[ptr2:ptr2+size/2], 7)
-	fill(memory[ptr2+size/2:ptr2+size-1], 5)
+	fill(memory[ptr1:ptr1+size/2], 5)
+	fill(memory[ptr1+size/2:ptr1+size-1], 7)
 
 	b.SetBytes(size/2 + 1)
 	b.ResetTimer()
 	for range b.N {
-		call(strcmp, ptr1, ptr2, size)
+		call(strrchr, ptr1, 5)
 	}
 }
 
-func Benchmark_strncmp(b *testing.B) {
+func Benchmark_memcmp(b *testing.B) {
 	clear(memory)
-	fill(memory[ptr1:ptr1+size-1], 7)
+	fill(memory[ptr1:ptr1+size], 7)
 	fill(memory[ptr2:ptr2+size/2], 7)
-	fill(memory[ptr2+size/2:ptr2+size-1], 5)
+	fill(memory[ptr2+size/2:ptr2+size], 5)
 
 	b.SetBytes(size/2 + 1)
 	b.ResetTimer()
 	for range b.N {
-		call(strncmp, ptr1, ptr2, size-1)
+		call(memcmp, ptr1, ptr2, size)
 	}
 }
 
@@ -195,53 +182,12 @@ func Benchmark_strcspn(b *testing.B) {
 	}
 }
 
-func Test_memchr(t *testing.T) {
-	for length := range 64 {
-		for pos := range length + 2 {
-			for alignment := range 24 {
-				clear(memory[:2*page])
-
-				ptr := (page - 8) + alignment
-				fill(memory[ptr:ptr+max(pos, length)], 5)
-				memory[ptr+pos] = 7
-
-				want := 0
-				if pos < length {
-					want = ptr + pos
-				}
-
-				got := call(memchr, uint64(ptr), 7, uint64(length))
-				if uint32(got) != uint32(want) {
-					t.Errorf("memchr(%d, %d, %d) = %d, want %d",
-						ptr, 7, uint64(length), uint32(got), uint32(want))
-				}
-			}
-		}
-
-		clear(memory)
-		ptr := len(memory) - length
-		fill(memory[ptr:ptr+length], 5)
-		memory[len(memory)-1] = 7
-
-		want := len(memory) - 1
-		if length == 0 {
-			want = 0
-		}
-
-		got := call(memchr, uint64(ptr), 7, uint64(length))
-		if uint32(got) != uint32(want) {
-			t.Errorf("memchr(%d, %d, %d) = %d, want %d",
-				ptr, 7, uint64(length), uint32(got), uint32(want))
-		}
-	}
-}
-
 func Test_strlen(t *testing.T) {
 	for length := range 64 {
 		for alignment := range 24 {
-			clear(memory[:2*page])
-
 			ptr := (page - 8) + alignment
+
+			clear(memory[:2*page])
 			fill(memory[ptr:ptr+length], 5)
 
 			got := call(strlen, uint64(ptr))
@@ -270,22 +216,62 @@ func Test_strlen(t *testing.T) {
 	}
 }
 
-func Test_strchr(t *testing.T) {
+func Test_memchr(t *testing.T) {
 	for length := range 64 {
 		for pos := range length + 2 {
 			for alignment := range 24 {
-				clear(memory[:2*page])
-
 				ptr := (page - 8) + alignment
-				fill(memory[ptr:ptr+max(pos, length)], 5)
-				memory[ptr+pos] = 7
-				memory[ptr+length] = 0
-
 				want := 0
 				if pos < length {
 					want = ptr + pos
 				}
 
+				clear(memory[:2*page])
+				fill(memory[ptr:ptr+max(pos, length)], 5)
+				memory[ptr+pos] = 7
+
+				got := call(memchr, uint64(ptr), 7, uint64(length))
+				if uint32(got) != uint32(want) {
+					t.Errorf("memchr(%d, %d, %d) = %d, want %d",
+						ptr, 7, uint64(length), uint32(got), uint32(want))
+				}
+			}
+		}
+
+		clear(memory)
+		ptr := len(memory) - length
+		fill(memory[ptr:ptr+length], 5)
+		memory[len(memory)-1] = 7
+
+		want := len(memory) - 1
+		if length == 0 {
+			want = 0
+		}
+
+		got := call(memchr, uint64(ptr), 7, uint64(length))
+		if uint32(got) != uint32(want) {
+			t.Errorf("memchr(%d, %d, %d) = %d, want %d",
+				ptr, 7, uint64(length), uint32(got), uint32(want))
+		}
+	}
+}
+
+func Test_strchr(t *testing.T) {
+	for length := range 64 {
+		for pos := range length + 2 {
+			for alignment := range 24 {
+				ptr := (page - 8) + alignment
+				want := 0
+				if pos < length {
+					want = ptr + pos
+				}
+
+				clear(memory[:2*page])
+				fill(memory[ptr:ptr+max(pos, length)], 5)
+				memory[ptr+pos] = 7
+				memory[ptr+pos+1] = 7
+				memory[ptr+length] = 0
+
 				got := call(strchr, uint64(ptr), 7)
 				if uint32(got) != uint32(want) {
 					t.Errorf("strchr(%d, %d) = %d, want %d",
@@ -312,21 +298,109 @@ func Test_strchr(t *testing.T) {
 	}
 }
 
+func Test_strrchr(t *testing.T) {
+	for length := range 64 {
+		for pos := range length + 2 {
+			for alignment := range 24 {
+				ptr := (page - 8) + alignment
+				want := 0
+				if pos < length {
+					want = ptr + pos
+				} else if length > 0 {
+					want = ptr
+				}
+
+				clear(memory[:2*page])
+				fill(memory[ptr:ptr+max(pos, length)], 5)
+				memory[ptr] = 7
+				memory[ptr+pos] = 7
+				memory[ptr+length] = 0
+
+				got := call(strrchr, uint64(ptr), 7)
+				if uint32(got) != uint32(want) {
+					t.Errorf("strrchr(%d, %d) = %d, want %d",
+						ptr, 7, uint32(got), uint32(want))
+				}
+			}
+		}
+
+		ptr := len(memory) - length
+		want := len(memory) - 2
+		if length <= 1 {
+			continue
+		}
+
+		clear(memory)
+		fill(memory[ptr:ptr+length], 5)
+		memory[ptr] = 7
+		memory[len(memory)-2] = 7
+		memory[len(memory)-1] = 0
+
+		got := call(strrchr, uint64(ptr), 7)
+		if uint32(got) != uint32(want) {
+			t.Errorf("strrchr(%d, %d) = %d, want %d",
+				ptr, 7, uint32(got), uint32(want))
+		}
+	}
+}
+
+const (
+	compareTest1 = "" +
+		"\x94\x63\x8f\x01\x74\x63\x8f\x01\x54\x63\x8f\x01\x34\x63\x8f\x01" +
+		"\xb4\xf2\x93\x01\x94\xf2\x93\x01\x54\xf1\x93\x01\x34\xf1\x93\x01" +
+		"\x14\xf1\x93\x01\x14\xf2\x93\x01\x34\xf2\x93\x01\x54\xf2\x93\x01" +
+		"\x74\xf2\x93\x01\x74\xf1\x93\x01\xd4\xf2\x93\x01\x94\xf1\x93\x01" +
+		"\xb4\xf1\x93\x01\xd4\xf1\x93\x01\xf4\xf1\x93\x01\xf4\xf2\x93\x01" +
+		"\x14\xf4\x93\x01\xf4\xf3\x93\x01\xd4\xf3\x93\x01\xb4\xf3\x93\x01" +
+		"\x94\xf3\x93\x01\x74\x80\x93\x01\x54\xf3\x93\x01\x34\xf3\x93\x01" +
+		"\x7f\xf3\x93\x01\x00\x01"
+	compareTest2 = "" +
+		"\x94\x63\x8f\x01\x74\x63\x8f\x01\x54\x63\x8f\x01\x34\x63\x8f\x01" +
+		"\xb4\xf2\x93\x01\x94\xf2\x93\x01\x54\xf1\x93\x01\x34\xf1\x93\x01" +
+		"\x14\xf1\x93\x01\x14\xf2\x93\x01\x34\xf2\x93\x01\x54\xf2\x93\x01" +
+		"\x74\xf2\x93\x01\x74\xf1\x93\x01\xd4\xf2\x93\x01\x94\xf1\x93\x01" +
+		"\xb4\xf1\x93\x01\xd4\xf1\x93\x01\xf4\xf1\x93\x01\xf4\xf2\x93\x01" +
+		"\xbc\x40\x96\x01\xf4\xf3\x93\x01\xd4\xf3\x93\x01\xb4\xf3\x93\x01" +
+		"\x94\xf3\x93\x01\x74\x7f\x93\x01\x54\xf3\x93\x01\x34\xf3\x93\x01" +
+		"\x80\xf3\x93\x01\x00\x02"
+)
+
+func Test_memcmp(t *testing.T) {
+	const s1 = compareTest1
+	const s2 = compareTest2
+
+	ptr2 := len(memory) - len(s2)
+
+	clear(memory)
+	copy(memory[ptr1:], s1)
+	copy(memory[ptr2:], s2)
+
+	for i := range len(s1) + 1 {
+		for j := range len(s1) - i {
+			want := strings.Compare(s1[i:i+j], s2[i:i+j])
+			got := call(memcmp, uint64(ptr1+i), uint64(ptr2+i), uint64(j))
+			if sign(int32(got)) != want {
+				t.Errorf("strcmp(%d, %d, %d) = %d, want %d",
+					ptr1+i, ptr2+i, j, int32(got), want)
+			}
+		}
+	}
+}
+
 func Test_strspn(t *testing.T) {
 	for length := range 64 {
 		for pos := range length + 2 {
 			for alignment := range 24 {
-				clear(memory[:2*page])
-
 				ptr := (page - 8) + alignment
+				want := min(pos, length)
+
+				clear(memory[:2*page])
 				fill(memory[ptr:ptr+max(pos, length)], 5)
 				memory[ptr+pos] = 7
 				memory[ptr+length] = 0
 				memory[128] = 3
 				memory[129] = 5
 
-				want := min(pos, length)
-
 				got := call(strspn, uint64(ptr), 129)
 				if uint32(got) != uint32(want) {
 					t.Errorf("strspn(%d, %d) = %d, want %d",
@@ -341,18 +415,18 @@ func Test_strspn(t *testing.T) {
 			}
 		}
 
-		clear(memory)
 		ptr := len(memory) - length
-		fill(memory[ptr:ptr+length], 5)
-		memory[len(memory)-1] = 7
-		memory[128] = 3
-		memory[129] = 5
-
 		want := length - 1
 		if length == 0 {
 			continue
 		}
 
+		clear(memory)
+		fill(memory[ptr:ptr+length], 5)
+		memory[len(memory)-1] = 7
+		memory[128] = 3
+		memory[129] = 5
+
 		got := call(strspn, uint64(ptr), 129)
 		if uint32(got) != uint32(want) {
 			t.Errorf("strspn(%d, %d) = %d, want %d",
@@ -371,17 +445,16 @@ func Test_strcspn(t *testing.T) {
 	for length := range 64 {
 		for pos := range length + 2 {
 			for alignment := range 24 {
-				clear(memory[:2*page])
-
 				ptr := (page - 8) + alignment
+				want := min(pos, length)
+
+				clear(memory[:2*page])
 				fill(memory[ptr:ptr+max(pos, length)], 5)
 				memory[ptr+pos] = 7
 				memory[ptr+length] = 0
 				memory[128] = 3
 				memory[129] = 7
 
-				want := min(pos, length)
-
 				got := call(strcspn, uint64(ptr), 129)
 				if uint32(got) != uint32(want) {
 					t.Errorf("strcspn(%d, %d) = %d, want %d",
@@ -396,18 +469,18 @@ func Test_strcspn(t *testing.T) {
 			}
 		}
 
-		clear(memory)
 		ptr := len(memory) - length
-		fill(memory[ptr:ptr+length], 5)
-		memory[len(memory)-1] = 7
-		memory[128] = 3
-		memory[129] = 7
-
 		want := length - 1
 		if length == 0 {
 			continue
 		}
 
+		clear(memory)
+		fill(memory[ptr:ptr+length], 5)
+		memory[len(memory)-1] = 7
+		memory[128] = 3
+		memory[129] = 7
+
 		got := call(strcspn, uint64(ptr), 129)
 		if uint32(got) != uint32(want) {
 			t.Errorf("strcspn(%d, %d) = %d, want %d",
@@ -422,8 +495,334 @@ func Test_strcspn(t *testing.T) {
 	}
 }
 
+type searchTest struct {
+	haystk string
+	needle string
+	out    int
+}
+
+var searchTests = []searchTest{
+	{"", "", 0},
+	{"", "a", -1},
+	{"", "foo", -1},
+	{"fo", "foo", -1},
+	{"foo", "baz", -1},
+	{"foo", "foo", 0},
+	{"oofofoofooo", "f", 2},
+	{"oofofoofooo", "foo", 4},
+	{"barfoobarfoo", "foo", 3},
+	{"foo", "", 0},
+	{"foo", "o", 1},
+	{"jrzm6jjhorimglljrea4w3rlgosts0w2gia17hno2td4qd1jz", "jz", 47},
+	{"ekkuk5oft4eq0ocpacknhwouic1uua46unx12l37nioq9wbpnocqks6", "ks6", 52},
+	{"999f2xmimunbuyew5vrkla9cpwhmxan8o98ec", "98ec", 33},
+	{"9lpt9r98i04k8bz6c6dsrthb96bhi", "96bhi", 24},
+	{"55u558eqfaod2r2gu42xxsu631xf0zobs5840vl", "5840vl", 33},
+	{"", "a", -1},
+	{"x", "a", -1},
+	{"x", "x", 0},
+	{"abc", "a", 0},
+	{"abc", "b", 1},
+	{"abc", "c", 2},
+	{"abc", "x", -1},
+	{"", "ab", -1},
+	{"bc", "ab", -1},
+	{"ab", "ab", 0},
+	{"xab", "ab", 1},
+	{"xab"[:2], "ab", -1},
+	{"", "abc", -1},
+	{"xbc", "abc", -1},
+	{"abc", "abc", 0},
+	{"xabc", "abc", 1},
+	{"xabc"[:3], "abc", -1},
+	{"xabxc", "abc", -1},
+	{"", "abcd", -1},
+	{"xbcd", "abcd", -1},
+	{"abcd", "abcd", 0},
+	{"xabcd", "abcd", 1},
+	{"xyabcd"[:5], "abcd", -1},
+	{"xbcqq", "abcqq", -1},
+	{"abcqq", "abcqq", 0},
+	{"xabcqq", "abcqq", 1},
+	{"xyabcqq"[:6], "abcqq", -1},
+	{"xabxcqq", "abcqq", -1},
+	{"xabcqxq", "abcqq", -1},
+	{"", "01234567", -1},
+	{"32145678", "01234567", -1},
+	{"01234567", "01234567", 0},
+	{"x01234567", "01234567", 1},
+	{"x0123456x01234567", "01234567", 9},
+	{"xx01234567"[:9], "01234567", -1},
+	{"", "0123456789", -1},
+	{"3214567844", "0123456789", -1},
+	{"0123456789", "0123456789", 0},
+	{"x0123456789", "0123456789", 1},
+	{"x012345678x0123456789", "0123456789", 11},
+	{"xyz0123456789"[:12], "0123456789", -1},
+	{"x01234567x89", "0123456789", -1},
+	{"", "0123456789012345", -1},
+	{"3214567889012345", "0123456789012345", -1},
+	{"0123456789012345", "0123456789012345", 0},
+	{"x0123456789012345", "0123456789012345", 1},
+	{"x012345678901234x0123456789012345", "0123456789012345", 17},
+	{"", "01234567890123456789", -1},
+	{"32145678890123456789", "01234567890123456789", -1},
+	{"01234567890123456789", "01234567890123456789", 0},
+	{"x01234567890123456789", "01234567890123456789", 1},
+	{"x0123456789012345678x01234567890123456789", "01234567890123456789", 21},
+	{"xyz01234567890123456789"[:22], "01234567890123456789", -1},
+	{"", "0123456789012345678901234567890", -1},
+	{"321456788901234567890123456789012345678911", "0123456789012345678901234567890", -1},
+	{"0123456789012345678901234567890", "0123456789012345678901234567890", 0},
+	{"x0123456789012345678901234567890", "0123456789012345678901234567890", 1},
+	{"x012345678901234567890123456789x0123456789012345678901234567890", "0123456789012345678901234567890", 32},
+	{"xyz0123456789012345678901234567890"[:33], "0123456789012345678901234567890", -1},
+	{"", "01234567890123456789012345678901", -1},
+	{"32145678890123456789012345678901234567890211", "01234567890123456789012345678901", -1},
+	{"01234567890123456789012345678901", "01234567890123456789012345678901", 0},
+	{"x01234567890123456789012345678901", "01234567890123456789012345678901", 1},
+	{"x0123456789012345678901234567890x01234567890123456789012345678901", "01234567890123456789012345678901", 33},
+	{"xyz01234567890123456789012345678901"[:34], "01234567890123456789012345678901", -1},
+	{"xxxxxx012345678901234567890123456789012345678901234567890123456789012", "012345678901234567890123456789012345678901234567890123456789012", 6},
+	{"", "0123456789012345678901234567890123456789", -1},
+	{"xx012345678901234567890123456789012345678901234567890123456789012", "0123456789012345678901234567890123456789", 2},
+	{"xx012345678901234567890123456789012345678901234567890123456789012"[:41], "0123456789012345678901234567890123456789", -1},
+	{"xx012345678901234567890123456789012345678901234567890123456789012", "0123456789012345678901234567890123456xxx", -1},
+	{"xx0123456789012345678901234567890123456789012345678901234567890120123456789012345678901234567890123456xxx", "0123456789012345678901234567890123456xxx", 65},
+	{"barfoobarfooyyyzzzyyyzzzyyyzzzyyyxxxzzzyyy", "x", 33},
+	{"fofofofooofoboo", "oo", 7},
+	{"fofofofofofoboo", "ob", 11},
+	{"fofofofofofoboo", "boo", 12},
+	{"fofofofofofoboo", "oboo", 11},
+	{"fofofofofoooboo", "fooo", 8},
+	{"fofofofofofoboo", "foboo", 10},
+	{"fofofofofofoboo", "fofob", 8},
+	{"fofofofofofofoffofoobarfoo", "foffof", 12},
+	{"fofofofofoofofoffofoobarfoo", "foffof", 13},
+	{"fofofofofofofoffofoobarfoo", "foffofo", 12},
+	{"fofofofofoofofoffofoobarfoo", "foffofo", 13},
+	{"fofofofofoofofoffofoobarfoo", "foffofoo", 13},
+	{"fofofofofofofoffofoobarfoo", "foffofoo", 12},
+	{"fofofofofoofofoffofoobarfoo", "foffofoob", 13},
+	{"fofofofofofofoffofoobarfoo", "foffofoob", 12},
+	{"fofofofofoofofoffofoobarfoo", "foffofooba", 13},
+	{"fofofofofofofoffofoobarfoo", "foffofooba", 12},
+	{"fofofofofoofofoffofoobarfoo", "foffofoobar", 13},
+	{"fofofofofofofoffofoobarfoo", "foffofoobar", 12},
+	{"fofofofofoofofoffofoobarfoo", "foffofoobarf", 13},
+	{"fofofofofofofoffofoobarfoo", "foffofoobarf", 12},
+	{"fofofofofoofofoffofoobarfoo", "foffofoobarfo", 13},
+	{"fofofofofofofoffofoobarfoo", "foffofoobarfo", 12},
+	{"fofofofofoofofoffofoobarfoo", "foffofoobarfoo", 13},
+	{"fofofofofofofoffofoobarfoo", "foffofoobarfoo", 12},
+	{"fofofofofoofofoffofoobarfoo", "ofoffofoobarfoo", 12},
+	{"fofofofofofofoffofoobarfoo", "ofoffofoobarfoo", 11},
+	{"fofofofofoofofoffofoobarfoo", "fofoffofoobarfoo", 11},
+	{"fofofofofofofoffofoobarfoo", "fofoffofoobarfoo", 10},
+	{"fofofofofoofofoffofoobarfoo", "foobars", -1},
+	{"foofyfoobarfoobar", "y", 4},
+	{"oooooooooooooooooooooo", "r", -1},
+	{"oxoxoxoxoxoxoxoxoxoxoxoy", "oy", 22},
+	{"oxoxoxoxoxoxoxoxoxoxoxox", "oy", -1},
+	{"oxoxoxoxoxoxoxoxoxoxox☺", "☺", 22},
+	{"xx0123456789012345678901234567890123456789012345678901234567890120123456789012345678901234567890123456xxx\xed\x9f\xc0", "\xed\x9f\xc0", 105},
+	{"000000000000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000000001", 5},
+}
+
+func Fuzz_memchr(f *testing.F) {
+	f.Fuzz(func(t *testing.T, s string, c, i byte) {
+		if len(s) > 128 || int(i) > len(s) {
+			t.SkipNow()
+		}
+		copy(memory[ptr1:], s)
+
+		got := call(memchr, ptr1+uint64(i), uint64(c), uint64(len(s)-int(i)))
+		want := strings.IndexByte(s[i:], c)
+		if want >= 0 {
+			want = ptr1 + int(i) + want
+		} else {
+			want = 0
+		}
+
+		if uint32(got) != uint32(want) {
+			t.Errorf("memchr(%q, %q) = %d, want %d",
+				s[i:], c, uint32(got), uint32(want))
+		}
+	})
+}
+
+func Fuzz_strchr(f *testing.F) {
+	f.Fuzz(func(t *testing.T, s string, c, i byte) {
+		if len(s) > 128 || int(i) > len(s) {
+			t.SkipNow()
+		}
+		copy(memory[ptr1:], s)
+		memory[ptr1+len(s)] = 0
+
+		got := call(strchr, ptr1+uint64(i), uint64(c))
+		want := bytes.IndexByte(term1(memory[ptr1+uint64(i):]), c)
+		if want >= 0 {
+			want = ptr1 + int(i) + want
+		} else {
+			want = 0
+		}
+
+		if uint32(got) != uint32(want) {
+			t.Errorf("strchr(%q, %q) = %d, want %d",
+				s[i:], c, uint32(got), uint32(want))
+		}
+	})
+}
+
+func Fuzz_strrchr(f *testing.F) {
+	f.Fuzz(func(t *testing.T, s string, c, i byte) {
+		if len(s) > 128 || int(i) > len(s) {
+			t.SkipNow()
+		}
+		copy(memory[ptr1:], s)
+		memory[ptr1+len(s)] = 0
+
+		got := call(strrchr, ptr1+uint64(i), uint64(c))
+		want := bytes.LastIndexByte(term1(memory[ptr1+uint64(i):]), c)
+		if want >= 0 {
+			want = ptr1 + int(i) + want
+		} else {
+			want = 0
+		}
+
+		if uint32(got) != uint32(want) {
+			t.Errorf("strrchr(%q, %q) = %d, want %d",
+				s[i:], c, uint32(got), uint32(want))
+		}
+	})
+}
+
+func Fuzz_memcmp(f *testing.F) {
+	const s1 = compareTest1
+	const s2 = compareTest2
+
+	for i := range len(compareTest1) + 1 {
+		f.Add(s1[i:], s2[i:])
+	}
+
+	f.Fuzz(func(t *testing.T, s1, s2 string) {
+		if len(s1) > 128 || len(s1) != len(s2) {
+			t.SkipNow()
+		}
+		copy(memory[ptr1:], s1)
+		copy(memory[ptr2:], s2)
+
+		got := call(memcmp, uint64(ptr1), uint64(ptr2), uint64(len(s1)))
+		want := strings.Compare(s1, s2)
+
+		if sign(int32(got)) != want {
+			t.Errorf("memcmp(%q, %q) = %d, want %d",
+				s1, s2, uint32(got), uint32(want))
+		}
+	})
+}
+
+func Fuzz_strspn(f *testing.F) {
+	for _, t := range searchTests {
+		f.Add(t.haystk, t.needle)
+	}
+
+	f.Fuzz(func(t *testing.T, s, chars string) {
+		if len(s) > 128 || len(chars) > 128 {
+			t.SkipNow()
+		}
+		copy(memory[ptr1:], s)
+		copy(memory[ptr2:], chars)
+		memory[ptr1+len(s)] = 0
+		memory[ptr2+len(chars)] = 0
+
+		got := call(strspn, uint64(ptr1), uint64(ptr2))
+
+		s = term(s)
+		chars = term(chars)
+		want := strings.IndexFunc(s, func(r rune) bool {
+			if uint32(r) >= utf8.RuneSelf {
+				t.Skip()
+			}
+			return strings.IndexByte(chars, byte(r)) < 0
+		})
+		if want < 0 {
+			want = len(s)
+		}
+
+		if uint32(got) != uint32(want) {
+			t.Errorf("strspn(%q, %q) = %d, want %d",
+				s, chars, uint32(got), uint32(want))
+		}
+	})
+}
+
+func Fuzz_strcspn(f *testing.F) {
+	for _, t := range searchTests {
+		f.Add(t.haystk, t.needle)
+	}
+
+	f.Fuzz(func(t *testing.T, s, chars string) {
+		if len(s) > 128 || len(chars) > 128 {
+			t.SkipNow()
+		}
+		if strings.ContainsFunc(chars, func(r rune) bool {
+			return uint32(r) >= utf8.RuneSelf
+		}) {
+			t.SkipNow()
+		}
+		copy(memory[ptr1:], s)
+		copy(memory[ptr2:], chars)
+		memory[ptr1+len(s)] = 0
+		memory[ptr2+len(chars)] = 0
+
+		got := call(strcspn, uint64(ptr1), uint64(ptr2))
+
+		s = term(s)
+		chars = term(chars)
+		want := strings.IndexAny(s, chars)
+		if want < 0 {
+			want = len(s)
+		}
+
+		if uint32(got) != uint32(want) {
+			t.Errorf("strcspn(%q, %q) = %d, want %d",
+				s, chars, uint32(got), uint32(want))
+		}
+	})
+}
+
+func sign(x int32) int {
+	switch {
+	case x > 0:
+		return +1
+	case x < 0:
+		return -1
+	default:
+		return 0
+	}
+}
+
 func fill(s []byte, v byte) {
 	for i := range s {
 		s[i] = v
 	}
 }
+
+func term[T interface{ []byte | string }](s T) T {
+	for i, c := range []byte(s) {
+		if c == 0 {
+			return s[:i]
+		}
+	}
+	return s
+}
+
+func term1[T interface{ []byte | string }](s T) T {
+	for i, c := range []byte(s) {
+		if c == 0 {
+			return s[:i+1]
+		}
+	}
+	return s
+}

sqlite3/libc/math.h

@@ -0,0 +1,36 @@
+#include_next <math.h>  // the system math.h
+
+#ifndef _WASM_SIMD128_MATH_H
+#define _WASM_SIMD128_MATH_H
+
+#include <wasm_simd128.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __wasm_relaxed_simd__
+
+// This header assumes "relaxed fused multiply-add"
+// is both faster and more precise.
+
+#define FP_FAST_FMA 1
+
+__attribute__((weak))
+double fma(double x, double y, double z) {
+  // If we get a software implementation from the host,
+  // this is enough to short circuit it on the 2nd lane.
+  const v128_t wx = wasm_f64x2_replace_lane(b, 0, x);
+  const v128_t wy = wasm_f64x2_splat(y);
+  const v128_t wz = wasm_f64x2_splat(z);
+  const v128_t wr = wasm_f64x2_relaxed_madd(wx, wy, wz);
+  return wasm_f64x2_extract_lane(wr, 0);
+}
+
+#endif  // __wasm_relaxed_simd__
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // _WASM_SIMD128_MATH_H

sqlite3/libc/stdlib.h

@@ -1,11 +1,8 @@
+#include_next <stdlib.h>  // the system stdlib.h
+
 #ifndef _WASM_SIMD128_STDLIB_H
 #define _WASM_SIMD128_STDLIB_H
 
-#include <stddef.h>
-#include <stdint.h>
-
-#include_next <stdlib.h>  // the system stdlib.h
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -17,22 +14,31 @@ extern "C" {
 __attribute__((weak))
 void qsort(void *base, size_t nel, size_t width,
            int (*comp)(const void *, const void *)) {
-  if (width == 0) return;
-
+  // If nel is zero, we're required to do nothing.
+  // If it's one, the array is already sorted.
   size_t wnel = width * nel;
   size_t gap = nel;
   while (gap > 1) {
+    // Use 64-bit unsigned arithmetic to avoid intermediate overflow.
+    // Absent overflow, gap will be strictly less than its previous value.
+    // Once it is one or zero, set it to one: do a final pass, and stop.
     gap = (5ull * gap - 1) / 11;
     if (gap == 0) gap = 1;
 
+    // It'd be undefined behavior for wnel to overflow a size_t;
+    // or if width is zero: the base pointer would be invalid.
+    // Since gap is stricly less than nel, we can assume
+    // wgap is strictly less than wnel.
     size_t wgap = width * gap;
     __builtin_assume(wgap < wnel);
     for (size_t i = wgap; i < wnel; i += width) {
+      // Even without overflow flags, the overflow builtin helps the compiler.
       for (size_t j = i; !__builtin_sub_overflow(j, wgap, &j);) {
         char *a = j + (char *)base;
         char *b = a + wgap;
         if (comp(a, b) <= 0) break;
 
+        // This well known loop is automatically vectorized.
         size_t s = width;
         do {
           char tmp = *a;

sqlite3/libc/string.h

@@ -1,14 +1,14 @@
+#include_next <string.h>  // the system string.h
+
 #ifndef _WASM_SIMD128_STRING_H
 #define _WASM_SIMD128_STRING_H
 
-#include <limits.h>
-#include <stddef.h>
+#include <ctype.h>
 #include <stdint.h>
+#include <strings.h>
 #include <wasm_simd128.h>
 #include <__macro_PAGESIZE.h>
 
-#include_next <string.h>  // the system string.h
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -19,17 +19,17 @@ extern "C" {
 // Clang will intrinsify using SIMD for small, constant N.
 // For everything else, this helps inlining.
 
-__attribute__((weak))
+__attribute__((weak, always_inline))
 void *memset(void *dest, int c, size_t n) {
   return __builtin_memset(dest, c, n);
 }
 
-__attribute__((weak))
-void *memcpy(void *restrict dest, const void *restrict src, size_t n) {
+__attribute__((weak, always_inline))
+void *memcpy(void *__restrict dest, const void *__restrict src, size_t n) {
   return __builtin_memcpy(dest, src, n);
 }
 
-__attribute__((weak))
+__attribute__((weak, always_inline))
 void *memmove(void *dest, const void *src, size_t n) {
   return __builtin_memmove(dest, src, n);
 }
@@ -38,220 +38,176 @@ void *memmove(void *dest, const void *src, size_t n) {
 
 #ifdef __wasm_simd128__
 
-// SIMD versions of some string.h functions.
-//
-// These assume aligned v128_t loads can't fail,
-// and so can't unaligned loads up to the last
-// aligned address less than memory size.
-//
-// These also assume unaligned access is not painfully slow,
-// but that bitmask extraction is really slow on AArch64.
-
 __attribute__((weak))
-int memcmp(const void *v1, const void *v2, size_t n) {
-  // memcmp can read up to n bytes from each object.
-  // Use unaligned loads to handle the case where
-  // the objects have mismatching alignments.
-  const v128_t *w1 = v1;
-  const v128_t *w2 = v2;
-  for (; n >= sizeof(v128_t); n -= sizeof(v128_t)) {
-    // Find any single bit difference.
-    if (wasm_v128_any_true(wasm_v128_load(w1) ^ wasm_v128_load(w2))) {
-      break;
+int memcmp(const void *vl, const void *vr, size_t n) {
+  // Scalar algorithm.
+  if (n < sizeof(v128_t)) {
+    const unsigned char *u1 = (unsigned char *)vl;
+    const unsigned char *u2 = (unsigned char *)vr;
+    while (n--) {
+      if (*u1 != *u2) return *u1 - *u2;
+      u1++;
+      u2++;
     }
-    w1++;
-    w2++;
+    return 0;
   }
 
-  // Continue byte-by-byte.
-  const unsigned char *u1 = (void *)w1;
-  const unsigned char *u2 = (void *)w2;
-  while (n--) {
-    if (*u1 != *u2) return *u1 - *u2;
-    u1++;
-    u2++;
+  // memcmp is allowed to read up to n bytes from each object.
+  // Find the first different character in the objects.
+  // Unaligned loads handle the case where the objects
+  // have mismatching alignments.
+  const v128_t *v1 = (v128_t *)vl;
+  const v128_t *v2 = (v128_t *)vr;
+  while (n) {
+    const v128_t cmp = wasm_i8x16_eq(wasm_v128_load(v1), wasm_v128_load(v2));
+    // Bitmask is slow on AArch64, all_true is much faster.
+    if (!wasm_i8x16_all_true(cmp)) {
+      // Find the offset of the first zero bit (little-endian).
+      size_t ctz = __builtin_ctz(~wasm_i8x16_bitmask(cmp));
+      const unsigned char *u1 = (unsigned char *)v1 + ctz;
+      const unsigned char *u2 = (unsigned char *)v2 + ctz;
+      // This may help the compiler if the function is inlined.
+      __builtin_assume(*u1 - *u2 != 0);
+      return *u1 - *u2;
+    }
+    // This makes n a multiple of sizeof(v128_t)
+    // for every iteration except the first.
+    size_t align = (n - 1) % sizeof(v128_t) + 1;
+    v1 = (v128_t *)((char *)v1 + align);
+    v2 = (v128_t *)((char *)v2 + align);
+    n -= align;
   }
   return 0;
 }
 
-__attribute__((weak))
-void *memchr(const void *v, int c, size_t n) {
+__attribute__((weak, noinline))
+void *memchr(const void *s, int c, size_t n) {
   // When n is zero, a function that locates a character finds no occurrence.
-  // Otherwise, decrement n to ensure __builtin_sub_overflow "overflows"
+  // Otherwise, decrement n to ensure sub_overflow overflows
   // when n would go equal-to-or-below zero.
-  if (n-- == 0) {
+  if (!n--) {
     return NULL;
   }
 
   // memchr must behave as if it reads characters sequentially
   // and stops as soon as a match is found.
-  // Aligning ensures loads can't fail.
-  uintptr_t align = (uintptr_t)v % sizeof(v128_t);
-  const v128_t *w = (void *)(v - align);
-  const v128_t wc = wasm_i8x16_splat(c);
+  // Aligning ensures loads beyond the first match are safe.
+  // Volatile avoids compiler tricks around out of bounds loads.
+  uintptr_t align = (uintptr_t)s % sizeof(v128_t);
+  const volatile v128_t *v = (v128_t *)((char *)s - align);
+  const v128_t vc = wasm_i8x16_splat(c);
 
-  while (true) {
-    const v128_t cmp = wasm_i8x16_eq(*w, wc);
+  for (;;) {
+    const v128_t cmp = wasm_i8x16_eq(*v, vc);
     // Bitmask is slow on AArch64, any_true is much faster.
     if (wasm_v128_any_true(cmp)) {
-      // Clear the bits corresponding to alignment
+      // Clear the bits corresponding to alignment (little-endian)
       // so we can count trailing zeros.
       int mask = wasm_i8x16_bitmask(cmp) >> align << align;
       // At least one bit will be set, unless we cleared them.
-      // Knowing this helps the compiler. 
+      // Knowing this helps the compiler.
       __builtin_assume(mask || align);
       // If the mask is zero because of alignment,
       // it's as if we didn't find anything.
       if (mask) {
-        // We found a match, unless it is beyond the end of the object.
+        // Find the offset of the first one bit (little-endian).
+        // That's a match, unless it is beyond the end of the object.
         // Recall that we decremented n, so less-than-or-equal-to is correct.
         size_t ctz = __builtin_ctz(mask);
-        return ctz <= n + align ? (void *)w + ctz : NULL;
+        return ctz - align <= n ? (char *)v + ctz : NULL;
       }
     }
-    // Decrement n; if it "overflows" we're done.
+    // Decrement n; if it overflows we're done.
     if (__builtin_sub_overflow(n, sizeof(v128_t) - align, &n)) {
       return NULL;
     }
     align = 0;
-    w++;
+    v++;
   }
 }
 
-__attribute__((weak))
+__attribute__((weak, noinline))
+void *memrchr(const void *s, int c, size_t n) {
+  // memrchr is allowed to read up to n bytes from the object.
+  // Search backward for the last matching character.
+  const v128_t *v = (v128_t *)((char *)s + n);
+  const v128_t vc = wasm_i8x16_splat(c);
+  for (; n >= sizeof(v128_t); n -= sizeof(v128_t)) {
+    const v128_t cmp = wasm_i8x16_eq(wasm_v128_load(--v), vc);
+    // Bitmask is slow on AArch64, any_true is much faster.
+    if (wasm_v128_any_true(cmp)) {
+      // Find the offset of the last one bit (little-endian).
+      size_t clz = __builtin_clz(wasm_i8x16_bitmask(cmp)) - 15;
+      return (char *)(v + 1) - clz;
+    }
+  }
+
+  // Scalar algorithm.
+  const char *a = (char *)v;
+  while (n--) {
+    if (*(--a) == (char)c) return (char *)a;
+  }
+  return NULL;
+}
+
+__attribute__((weak, noinline))
 size_t strlen(const char *s) {
   // strlen must stop as soon as it finds the terminator.
-  // Aligning ensures loads can't fail.
+  // Aligning ensures loads beyond the terminator are safe.
   uintptr_t align = (uintptr_t)s % sizeof(v128_t);
-  const v128_t *w = (void *)(s - align);
+  const volatile v128_t *v = (v128_t *)(s - align);
 
-  while (true) {
+  for (;;) {
+    const v128_t vv = *v;
     // Bitmask is slow on AArch64, all_true is much faster.
-    if (!wasm_i8x16_all_true(*w)) {
-      const v128_t cmp = wasm_i8x16_eq(*w, (v128_t){});
-      // Clear the bits corresponding to alignment
+    if (!wasm_i8x16_all_true(vv)) {
+      const v128_t cmp = wasm_i8x16_eq(vv, (v128_t){});
+      // Clear the bits corresponding to alignment (little-endian)
       // so we can count trailing zeros.
       int mask = wasm_i8x16_bitmask(cmp) >> align << align;
       // At least one bit will be set, unless we cleared them.
-      // Knowing this helps the compiler. 
+      // Knowing this helps the compiler.
       __builtin_assume(mask || align);
+      // If the mask is zero because of alignment,
+      // it's as if we didn't find anything.
       if (mask) {
-        return (char *)w - s + __builtin_ctz(mask);
+        // Find the offset of the first one bit (little-endian).
+        return (char *)v - s + __builtin_ctz(mask);
       }
     }
     align = 0;
-    w++;
+    v++;
   }
 }
 
-static int __strcmp(const char *s1, const char *s2) {
-  // Set limit to the largest possible valid v128_t pointer.
-  // Unsigned modular arithmetic gives the correct result
-  // unless memory size is zero, in which case all pointers are invalid.
-  const v128_t *const limit =
-      (v128_t *)(__builtin_wasm_memory_size(0) * PAGESIZE) - 1;
-
-  // Use unaligned loads to handle the case where
-  // the strings have mismatching alignments.
-  const v128_t *w1 = (void *)s1;
-  const v128_t *w2 = (void *)s2;
-  while (w1 <= limit && w2 <= limit) {
-    // Find any single bit difference.
-    if (wasm_v128_any_true(wasm_v128_load(w1) ^ wasm_v128_load(w2))) {
-      break;
-    }
-    // All bytes are equal.
-    // If any byte is zero (on both strings) the strings are equal.
-    if (!wasm_i8x16_all_true(wasm_v128_load(w1))) {
-      return 0;
-    }
-    w1++;
-    w2++;
-  }
-
-  // Continue byte-by-byte.
-  const unsigned char *u1 = (void *)w1;
-  const unsigned char *u2 = (void *)w2;
-  while (true) {
-    if (*u1 != *u2) return *u1 - *u2;
-    if (*u1 == 0) break;
-    u1++;
-    u2++;
-  }
-  return 0;
-}
-
-__attribute__((weak, always_inline))
-int strcmp(const char *s1, const char *s2) {
-  // Use strncmp when comparing against literal strings.
-  // If the literal is small, the vector search will be skipped.
-  if (__builtin_constant_p(strlen(s2))) {
-    return strncmp(s1, s2, strlen(s2));
-  }
-  return __strcmp(s1, s2);
-}
-
-__attribute__((weak))
-int strncmp(const char *s1, const char *s2, size_t n) {
-  // Set limit to the largest possible valid v128_t pointer.
-  // Unsigned modular arithmetic gives the correct result
-  // unless memory size is zero, in which case all pointers are invalid.
-  const v128_t *const limit =
-      (v128_t *)(__builtin_wasm_memory_size(0) * PAGESIZE) - 1;
-
-  // Use unaligned loads to handle the case where
-  // the strings have mismatching alignments.
-  const v128_t *w1 = (void *)s1;
-  const v128_t *w2 = (void *)s2;
-  for (; w1 <= limit && w2 <= limit && n >= sizeof(v128_t); n -= sizeof(v128_t)) {
-    // Find any single bit difference.
-    if (wasm_v128_any_true(wasm_v128_load(w1) ^ wasm_v128_load(w2))) {
-      break;
-    }
-    // All bytes are equal.
-    // If any byte is zero (on both strings) the strings are equal.
-    if (!wasm_i8x16_all_true(wasm_v128_load(w1))) {
-      return 0;
-    }
-    w1++;
-    w2++;
-  }
-
-  // Continue byte-by-byte.
-  const unsigned char *u1 = (void *)w1;
-  const unsigned char *u2 = (void *)w2;
-  while (n--) {
-    if (*u1 != *u2) return *u1 - *u2;
-    if (*u1 == 0) break;
-    u1++;
-    u2++;
-  }
-  return 0;
-}
-
 static char *__strchrnul(const char *s, int c) {
-  // strchrnul must stop as soon as a match is found.
-  // Aligning ensures loads can't fail.
+  // strchrnul must stop as soon as it finds the terminator.
+  // Aligning ensures loads beyond the terminator are safe.
+  // Volatile avoids compiler tricks around out of bounds loads.
   uintptr_t align = (uintptr_t)s % sizeof(v128_t);
-  const v128_t *w = (void *)(s - align);
-  const v128_t wc = wasm_i8x16_splat(c);
+  const volatile v128_t *v = (v128_t *)(s - align);
+  const v128_t vc = wasm_i8x16_splat(c);
 
-  while (true) {
-    const v128_t cmp = wasm_i8x16_eq(*w, (v128_t){}) | wasm_i8x16_eq(*w, wc);
+  for (;;) {
+    const v128_t vv = *v;
+    const v128_t cmp = wasm_i8x16_eq(vv, (v128_t){}) | wasm_i8x16_eq(vv, vc);
     // Bitmask is slow on AArch64, any_true is much faster.
     if (wasm_v128_any_true(cmp)) {
-      // Clear the bits corresponding to alignment
+      // Clear the bits corresponding to alignment (little-endian)
       // so we can count trailing zeros.
       int mask = wasm_i8x16_bitmask(cmp) >> align << align;
       // At least one bit will be set, unless we cleared them.
-      // Knowing this helps the compiler. 
+      // Knowing this helps the compiler.
       __builtin_assume(mask || align);
+      // If the mask is zero because of alignment,
+      // it's as if we didn't find anything.
       if (mask) {
-        return (char *)w + __builtin_ctz(mask);
+        // Find the offset of the first one bit (little-endian).
+        return (char *)v + __builtin_ctz(mask);
       }
     }
     align = 0;
-    w++;
+    v++;
   }
 }
 
@@ -271,97 +227,247 @@ char *strchr(const char *s, int c) {
     return (char *)s + strlen(s);
   }
   char *r = __strchrnul(s, c);
-  return *(char *)r == (char)c ? r : NULL;
+  return *r == (char)c ? r : NULL;
 }
 
-__attribute__((weak))
+__attribute__((weak, always_inline))
+char *strrchr(const char *s, int c) {
+  // For finding the terminator, strlen is faster.
+  if (__builtin_constant_p(c) && (char)c == 0) {
+    return (char *)s + strlen(s);
+  }
+  // This could also be implemented in a single pass using strchr,
+  // advancing to the next match until no more matches are found.
+  // That would be suboptimal with lots of consecutive matches.
+  return (char *)memrchr(s, c, strlen(s) + 1);
+}
+
+// SIMDized check which bytes are in a set (Geoff Langdale)
+// http://0x80.pl/notesen/2018-10-18-simd-byte-lookup.html
+
+typedef struct {
+  __u8x16 l;
+  __u8x16 h;
+} __wasm_v128_bitmap256_t;
+
+__attribute__((always_inline))
+static void __wasm_v128_setbit(__wasm_v128_bitmap256_t *bitmap, int i) {
+  uint8_t hi_nibble = (uint8_t)i >> 4;
+  uint8_t lo_nibble = (uint8_t)i & 0xf;
+  bitmap->l[lo_nibble] |= 1 << (hi_nibble - 0);
+  bitmap->h[lo_nibble] |= 1 << (hi_nibble - 8);
+}
+
+#ifndef __wasm_relaxed_simd__
+
+#define wasm_i8x16_relaxed_swizzle wasm_i8x16_swizzle
+
+#endif  // __wasm_relaxed_simd__
+
+__attribute__((always_inline))
+static v128_t __wasm_v128_chkbits(__wasm_v128_bitmap256_t bitmap, v128_t v) {
+  v128_t indices_0_7 = v & wasm_u8x16_const_splat(0x8f);
+  v128_t indices_8_15 = (v & wasm_u8x16_const_splat(0x80)) ^ indices_0_7;
+
+  v128_t row_0_7 = wasm_i8x16_swizzle(bitmap.l, indices_0_7);
+  v128_t row_8_15 = wasm_i8x16_swizzle(bitmap.h, indices_8_15);
+
+  v128_t bitsets = row_0_7 | row_8_15;
+
+  v128_t hi_nibbles = wasm_u8x16_shr(v, 4);
+  v128_t bitmask_lookup = wasm_u8x16_const(1, 2, 4, 8, 16, 32, 64, 128,  //
+                                           1, 2, 4, 8, 16, 32, 64, 128);
+  v128_t bitmask = wasm_i8x16_relaxed_swizzle(bitmask_lookup, hi_nibbles);
+
+  return wasm_i8x16_eq(bitsets & bitmask, bitmask);
+}
+
+#undef wasm_i8x16_relaxed_swizzle
+
+__attribute__((weak, noinline))
 size_t strspn(const char *s, const char *c) {
-#ifndef _REENTRANT
-  static // Avoid the stack for builds without threads.
-#endif
-  char byteset[UCHAR_MAX + 1];
-  const char *const a = s;
+  // strspn must stop as soon as it finds the terminator.
+  // Aligning ensures loads beyond the terminator are safe.
+  // Volatile avoids compiler tricks around out of bounds loads.
+  uintptr_t align = (uintptr_t)s % sizeof(v128_t);
+  const volatile v128_t *v = (v128_t *)(s - align);
 
   if (!c[0]) return 0;
   if (!c[1]) {
-    // Set limit to the largest possible valid v128_t pointer.
-    // Unsigned modular arithmetic gives the correct result
-    // unless memory size is zero, in which case all pointers are invalid.
-    const v128_t *const limit =
-        (v128_t *)(__builtin_wasm_memory_size(0) * PAGESIZE) - 1;
-
-    const v128_t *w = (void *)s;
-    const v128_t wc = wasm_i8x16_splat(*c);
-    while (w <= limit) {
-      if (!wasm_i8x16_all_true(wasm_i8x16_eq(wasm_v128_load(w), wc))) {
-        break;
+    const v128_t vc = wasm_i8x16_splat(*c);
+    for (;;) {
+      const v128_t cmp = wasm_i8x16_eq(*v, vc);
+      // Bitmask is slow on AArch64, all_true is much faster.
+      if (!wasm_i8x16_all_true(cmp)) {
+        // Clear the bits corresponding to alignment (little-endian)
+        // so we can count trailing zeros.
+        int mask = (uint16_t)~wasm_i8x16_bitmask(cmp) >> align << align;
+        // At least one bit will be set, unless we cleared them.
+        // Knowing this helps the compiler.
+        __builtin_assume(mask || align);
+        // If the mask is zero because of alignment,
+        // 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);
+        }
       }
-      w++;
+      align = 0;
+      v++;
     }
-
-    s = (void *)w;
-    while (*s == *c) s++;
-    return s - a;
   }
 
-#if !__OPTIMIZE__ || __OPTIMIZE_SIZE__
+  __wasm_v128_bitmap256_t bitmap = {};
 
-  // Unoptimized version.
-  memset(byteset, 0, sizeof(byteset));
-  while (*c && (byteset[*(unsigned char *)c] = 1)) c++;
-  while (byteset[*(unsigned char *)s]) s++;
+  for (; *c; c++) {
+    // Terminator IS NOT on the bitmap.
+    __wasm_v128_setbit(&bitmap, *c);
+  }
 
-#else
+  for (;;) {
+    const v128_t cmp = __wasm_v128_chkbits(bitmap, *v);
+    // Bitmask is slow on AArch64, all_true is much faster.
+    if (!wasm_i8x16_all_true(cmp)) {
+      // Clear the bits corresponding to alignment (little-endian)
+      // so we can count trailing zeros.
+      int mask = (uint16_t)~wasm_i8x16_bitmask(cmp) >> align << align;
+      // At least one bit will be set, unless we cleared them.
+      // Knowing this helps the compiler.
+      __builtin_assume(mask || align);
+      // If the mask is zero because of alignment,
+      // 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++;
+  }
+}
 
-  // This is faster than memset.
-  volatile v128_t *w = (void *)byteset;
-  #pragma unroll
-  for (size_t i = sizeof(byteset) / sizeof(v128_t); i--;) w[i] = (v128_t){};
-  static_assert(sizeof(byteset) % sizeof(v128_t) == 0);
+__attribute__((weak, noinline))
+size_t strcspn(const char *s, const char *c) {
+  if (!c[0] || !c[1]) return __strchrnul(s, *c) - s;
 
-  // Keeping byteset[0] = 0 avoids the other loop having to test for it.
-  while (*c && (byteset[*(unsigned char *)c] = 1)) c++;
-  #pragma unroll 4
-  while (byteset[*(unsigned char *)s]) s++;
+  // strcspn must stop as soon as it finds the terminator.
+  // Aligning ensures loads beyond the terminator are safe.
+  // Volatile avoids compiler tricks around out of bounds loads.
+  uintptr_t align = (uintptr_t)s % sizeof(v128_t);
+  const volatile v128_t *v = (v128_t *)(s - align);
 
-#endif
+  __wasm_v128_bitmap256_t bitmap = {};
 
-  return s - a;
+  do {
+    // Terminator IS on the bitmap.
+    __wasm_v128_setbit(&bitmap, *c);
+  } while (*c++);
+
+  for (;;) {
+    const v128_t cmp = __wasm_v128_chkbits(bitmap, *v);
+    // Bitmask is slow on AArch64, any_true is much faster.
+    if (wasm_v128_any_true(cmp)) {
+      // Clear the bits corresponding to alignment (little-endian)
+      // so we can count trailing zeros.
+      int mask = wasm_i8x16_bitmask(cmp) >> align << align;
+      // At least one bit will be set, unless we cleared them.
+      // Knowing this helps the compiler.
+      __builtin_assume(mask || align);
+      // If the mask is zero because of alignment,
+      // 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++;
+  }
+}
+
+// Given the above SIMD implementations,
+// these are best implemented as
+// small wrappers over those functions.
+
+// Simple wrappers already in musl:
+//  - mempcpy
+//  - strcat
+//  - strlcat
+//  - strdup
+//  - strndup
+//  - strnlen
+//  - strpbrk
+//  - strsep
+//  - strtok
+
+__attribute__((weak))
+void *memccpy(void *__restrict dest, const void *__restrict src, int c,
+              size_t n) {
+  const void *m = memchr(src, c, n);
+  if (m != NULL) {
+    n = (char *)m - (char *)src + 1;
+    m = (char *)dest + n;
+  }
+  memcpy(dest, src, n);
+  return (void *)m;
 }
 
 __attribute__((weak))
-size_t strcspn(const char *s, const char *c) {
-#ifndef _REENTRANT
-  static // Avoid the stack for builds without threads.
-#endif
-  char byteset[UCHAR_MAX + 1];
-  const char *const a = s;
+size_t strlcpy(char *__restrict dest, const char *__restrict src, size_t n) {
+  size_t slen = strlen(src);
+  if (n--) {
+    if (n > slen) n = slen;
+    memcpy(dest, src, n);
+    dest[n] = 0;
+  }
+  return slen;
+}
 
-  if (!c[0] || !c[1]) return __strchrnul(s, *c) - s;
+__attribute__((weak))
+char *strncat(char *__restrict dest, const char *__restrict src, size_t n) {
+  size_t strnlen(const char *s, size_t n);
+  size_t dlen = strlen(dest);
+  size_t slen = strnlen(src, n);
+  memcpy(dest + dlen, src, slen);
+  dest[dlen + slen] = 0;
+  return dest;
+}
 
-#if !__OPTIMIZE__ || __OPTIMIZE_SIZE__
+static char *__stpcpy(char *__restrict dest, const char *__restrict src) {
+  size_t slen = strlen(src);
+  memcpy(dest, src, slen + 1);
+  return dest + slen;
+}
 
-  // Unoptimized version.
-  memset(byteset, 0, sizeof(byteset));
-  while ((byteset[*(unsigned char *)c] = 1) && *c) c++;
-  while (!byteset[*(unsigned char *)s]) s++;
+static char *__stpncpy(char *__restrict dest, const char *__restrict src,
+                       size_t n) {
+  size_t strnlen(const char *s, size_t n);
+  size_t slen = strnlen(src, n);
+  memcpy(dest, src, slen);
+  memset(dest + slen, 0, n - slen);
+  return dest + slen;
+}
 
-#else
+__attribute__((weak, always_inline))
+char *stpcpy(char *__restrict dest, const char *__restrict src) {
+  return __stpcpy(dest, src);
+}
 
-  // This is faster than memset.
-  volatile v128_t *w = (void *)byteset;
-  #pragma unroll
-  for (size_t i = sizeof(byteset) / sizeof(v128_t); i--;) w[i] = (v128_t){};
-  static_assert(sizeof(byteset) % sizeof(v128_t) == 0);
+__attribute__((weak, always_inline))
+char *strcpy(char *__restrict dest, const char *__restrict src) {
+  __stpcpy(dest, src);
+  return dest;
+}
 
-  // Setting byteset[0] = 1 avoids the other loop having to test for it.
-  while ((byteset[*(unsigned char *)c] = 1) && *c) c++;
-  #pragma unroll 4
-  while (!byteset[*(unsigned char *)s]) s++;
+__attribute__((weak, always_inline))
+char *stpncpy(char *__restrict dest, const char *__restrict src, size_t n) {
+  return __stpncpy(dest, src, n);
+}
 
-#endif
-
-  return s - a;
+__attribute__((weak, always_inline))
+char *strncpy(char *__restrict dest, const char *__restrict src, size_t n) {
+  __stpncpy(dest, src, n);
+  return dest;
 }
 
 #endif  // __wasm_simd128__

sqlite3/vfs_find.patch

@@ -1,7 +1,7 @@
 # Remove VFS registration. Go handles it.
 --- sqlite3.c.orig
 +++ sqlite3.c
-@@ -26725,7 +26725,7 @@
+@@ -26726,7 +26726,7 @@
    sqlite3_free(p);
    return sqlite3_os_init();
  }
@@ -10,7 +10,7 @@
  /*
  ** The list of all registered VFS implementations.
  */
-@@ -26822,7 +26822,7 @@
+@@ -26823,7 +26823,7 @@
    sqlite3_mutex_leave(mutex);
    return SQLITE_OK;
  }

stmt.go

@@ -367,11 +367,9 @@ func (s *Stmt) BindPointer(param int, ptr any) error {
 //
 // https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindJSON(param int, value any) error {
-	data, err := json.Marshal(value)
-	if err != nil {
-		return err
-	}
-	return s.BindRawText(param, data)
+	return json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
+		return 0, s.BindRawText(param, p[:len(p)-1]) // remove the newline
+	})).Encode(value)
 }
 
 // BindValue binds a copy of value to the prepared statement.
@@ -751,3 +749,7 @@ func (s *Stmt) columns(count int64) ([]byte, ptr_t, error) {
 
 	return util.View(s.c.mod, typePtr, count), dataPtr, nil
 }
+
+type callbackWriter func(p []byte) (int, error)
+
+func (fn callbackWriter) Write(p []byte) (int, error) { return fn(p) }

tests/config_test.go

@@ -114,6 +114,7 @@ func TestConn_FileControl(t *testing.T) {
 			t.Errorf("got %v, want MISUSE", err)
 		}
 	})
+
 	t.Run("FCNTL_RESET_CACHE", func(t *testing.T) {
 		o, err := db.FileControl("", sqlite3.FCNTL_RESET_CACHE)
 		if err != nil {
@@ -237,6 +238,16 @@ func TestConn_FileControl(t *testing.T) {
 			t.Errorf("got %v, want LOCK_EXCLUSIVE", o)
 		}
 	})
+
+	t.Run("FCNTL_NULL_IO", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_NULL_IO)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != nil {
+			t.Errorf("got %v, want nil", o)
+		}
+	})
 }
 
 func TestConn_Limit(t *testing.T) {

tests/conn_test.go

@@ -295,6 +295,17 @@ func TestConn_Filename(t *testing.T) {
 	t.Parallel()
 
 	file := filepath.Join(t.TempDir(), "test.db")
+	f, err := os.Create(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+
+	file, err = filepath.EvalSymlinks(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	db, err := sqlite3.Open(file)
 	if err != nil {
 		t.Fatal(err)

util/osutil/osfs.go

@@ -32,10 +32,3 @@ func (FS) Stat(name string) (fs.FileInfo, error) {
 func (FS) ReadFile(name string) ([]byte, error) {
 	return os.ReadFile(name)
 }
-
-// OpenFile behaves the same as [os.OpenFile].
-//
-// Deprecated: use os.OpenFile instead.
-func OpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
-	return os.OpenFile(name, flag, perm)
-}

util/sql3util/wasm/build.sh

@@ -14,9 +14,9 @@ trap 'rm -f sql3parse_table.tmp' EXIT
 	-o sql3parse_table.wasm main.c \
 	-I"$ROOT/sqlite3/libc" -I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -25,6 +25,6 @@ trap 'rm -f sql3parse_table.tmp' EXIT
 "$BINARYEN/wasm-ctor-eval" -c _initialize sql3parse_table.wasm -o sql3parse_table.tmp
 "$BINARYEN/wasm-opt" --strip --strip-debug --strip-producers -c -Oz \
 	sql3parse_table.tmp -o sql3parse_table.wasm --low-memory-unused \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue

vfs/README.md

@@ -23,7 +23,7 @@ POSIX advisory locks,
 which SQLite uses on [Unix](https://github.com/sqlite/sqlite/blob/5d60f4/src/os_unix.c#L13-L14),
 are [broken by design](https://github.com/sqlite/sqlite/blob/5d60f4/src/os_unix.c#L1074-L1162).
 Instead, on Linux and macOS, this package uses
-[OFD locks](https://www.gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html)
+[OFD locks](https://gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html)
 to synchronize access to database files.
 
 This package can also use

vfs/const.go

@@ -234,6 +234,7 @@ const (
 	_FCNTL_CKSM_FILE             _FcntlOpcode = 41
 	_FCNTL_RESET_CACHE           _FcntlOpcode = 42
 	_FCNTL_NULL_IO               _FcntlOpcode = 43
+	_FCNTL_BLOCK_ON_CONNECT      _FcntlOpcode = 44
 )
 
 // https://sqlite.org/c3ref/c_shm_exclusive.html
@@ -246,6 +247,6 @@ const (
 	_SHM_EXCLUSIVE _ShmFlag = 8
 
 	_SHM_NLOCK = 8
-	_SHM_BASE  = 120
+	_SHM_BASE  = (22 + _SHM_NLOCK) * 4
 	_SHM_DMS   = _SHM_BASE + _SHM_NLOCK
 )

vfs/file.go

@@ -13,22 +13,28 @@ import (
 type vfsOS struct{}
 
 func (vfsOS) FullPathname(path string) (string, error) {
-	path, err := filepath.Abs(path)
+	link, err := evalSymlinks(path)
 	if err != nil {
 		return "", err
 	}
-	return path, testSymlinks(filepath.Dir(path))
+	full, err := filepath.Abs(link)
+	if err == nil && link != path {
+		err = _OK_SYMLINK
+	}
+	return full, err
 }
 
-func testSymlinks(path string) error {
-	p, err := filepath.EvalSymlinks(path)
+func evalSymlinks(path string) (string, error) {
+	var file string
+	_, err := os.Lstat(path)
+	if errors.Is(err, fs.ErrNotExist) {
+		path, file = filepath.Split(path)
+	}
+	path, err = filepath.EvalSymlinks(path)
 	if err != nil {
-		return err
+		return "", err
 	}
-	if p != path {
-		return _OK_SYMLINK
-	}
-	return nil
+	return filepath.Join(path, file), nil
 }
 
 func (vfsOS) Delete(path string, syncDir bool) error {

vfs/memdb/memdb.go

@@ -28,9 +28,8 @@ func (memVFS) Open(name string, flags vfs.OpenFlag) (vfs.File, vfs.OpenFlag, err
 	//
 	// We refuse to open all other file types,
 	// but returning OPEN_MEMORY means SQLite won't ask us to.
-	const types = vfs.OPEN_MAIN_DB |
-		vfs.OPEN_TEMP_DB |
-		vfs.OPEN_TEMP_JOURNAL
+	const types = vfs.OPEN_MAIN_DB | vfs.OPEN_TEMP_DB |
+		vfs.OPEN_TRANSIENT_DB | vfs.OPEN_TEMP_JOURNAL
 	if flags&types == 0 {
 		// notest // OPEN_MEMORY
 		return nil, flags, sqlite3.CANTOPEN

vfs/shm_windows.go

@@ -26,7 +26,6 @@ type vfsShm struct {
 	ptrs     []ptr_t
 	stack    [1]stk_t
 	fileLock bool
-	blocking bool
 	sync.Mutex
 }
 

vfs/tests/mptest/wasm/build.sh

@@ -10,9 +10,9 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-o mptest.wasm main.c \
 	-I"$ROOT/sqlite3/libc" -I"$ROOT/sqlite3" \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -27,7 +27,7 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
 	mptest.wasm -o mptest.tmp --low-memory-unused \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue
 mv mptest.tmp mptest.wasm

vfs/tests/speedtest1/wasm/build.sh

@@ -10,9 +10,9 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-o speedtest1.wasm main.c \
 	-I"$ROOT/sqlite3/libc" -I"$ROOT/sqlite3" \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -22,7 +22,7 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
 	speedtest1.wasm -o speedtest1.tmp --low-memory-unused \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue
 mv speedtest1.tmp speedtest1.wasm

vfs/vfs.go

@@ -381,6 +381,10 @@ func vfsFileControlImpl(ctx context.Context, mod api.Module, file File, op _Fcnt
 			file.SetDB(ctx.Value(util.ConnKey{}))
 			return _OK
 		}
+
+	case _FCNTL_NULL_IO:
+		file.Close()
+		return _OK
 	}
 
 	return _NOTFOUND