From e257b532911fd1d95fe1093cc4e91dfe2817e3e4 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 15 Jul 2024 03:50:57 +0000 Subject: [PATCH] Bump github.com/ncruces/go-sqlite3 from 0.15.0 to 0.17.1 Bumps [github.com/ncruces/go-sqlite3](https://github.com/ncruces/go-sqlite3) from 0.15.0 to 0.17.1. - [Release notes](https://github.com/ncruces/go-sqlite3/releases) - [Commits](https://github.com/ncruces/go-sqlite3/compare/v0.15.0...v0.17.1) --- updated-dependencies: - dependency-name: github.com/ncruces/go-sqlite3 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- go.mod | 10 +- go.sum | 20 +- .../github.com/ncruces/go-sqlite3/README.md | 15 +- vendor/github.com/ncruces/go-sqlite3/conn.go | 37 +- .../ncruces/go-sqlite3/driver/driver.go | 31 +- .../ncruces/go-sqlite3/embed/README.md | 8 +- .../ncruces/go-sqlite3/embed/build.sh | 5 +- .../ncruces/go-sqlite3/embed/exports.txt | 3 + .../ncruces/go-sqlite3/embed/sqlite3.wasm | Bin 1337796 -> 1364101 bytes vendor/github.com/ncruces/go-sqlite3/func.go | 5 +- .../github.com/ncruces/go-sqlite3/go.work.sum | 9 +- .../go-sqlite3/internal/alloc/alloc_other.go | 9 + .../go-sqlite3/internal/alloc/alloc_slice.go | 24 + .../{util/alloc.go => alloc/alloc_unix.go} | 20 +- .../internal/alloc/alloc_windows.go | 76 +++ .../ncruces/go-sqlite3/internal/util/const.go | 2 +- .../ncruces/go-sqlite3/internal/util/error.go | 10 + .../ncruces/go-sqlite3/internal/util/json.go | 2 +- .../ncruces/go-sqlite3/internal/util/mmap.go | 27 +- .../go-sqlite3/internal/util/mmap_other.go | 19 +- .../go-sqlite3/internal/util/module.go | 2 +- vendor/github.com/ncruces/go-sqlite3/json.go | 3 +- .../github.com/ncruces/go-sqlite3/pointer.go | 3 +- .../github.com/ncruces/go-sqlite3/registry.go | 30 ++ .../github.com/ncruces/go-sqlite3/sqlite.go | 16 +- vendor/github.com/ncruces/go-sqlite3/stmt.go | 54 ++- vendor/github.com/ncruces/go-sqlite3/time.go | 12 +- vendor/github.com/ncruces/go-sqlite3/value.go | 6 +- .../ncruces/go-sqlite3/vfs/README.md | 61 ++- .../github.com/ncruces/go-sqlite3/vfs/api.go | 4 +- .../ncruces/go-sqlite3/vfs/const.go | 2 + .../github.com/ncruces/go-sqlite3/vfs/file.go | 3 + .../github.com/ncruces/go-sqlite3/vfs/lock.go | 2 +- .../ncruces/go-sqlite3/vfs/lock_other.go | 2 +- .../ncruces/go-sqlite3/vfs/os_bsd.go | 9 +- .../ncruces/go-sqlite3/vfs/os_darwin.go | 2 +- .../ncruces/go-sqlite3/vfs/os_linux.go | 4 +- .../ncruces/go-sqlite3/vfs/os_std_sleep.go | 9 - .../ncruces/go-sqlite3/vfs/os_unix_lock.go | 7 +- .../ncruces/go-sqlite3/vfs/os_windows.go | 15 +- .../github.com/ncruces/go-sqlite3/vfs/shm.go | 46 +- .../ncruces/go-sqlite3/vfs/shm_bsd.go | 260 +++++++++++ .../ncruces/go-sqlite3/vfs/shm_other.go | 2 +- .../github.com/ncruces/go-sqlite3/vfs/vfs.go | 12 +- vendor/github.com/ncruces/go-sqlite3/vtab.go | 31 +- .../github.com/tetratelabs/wazero/config.go | 19 +- .../wazero/experimental/checkpoint.go | 13 - .../wazero/experimental/listener.go | 6 - .../experimental/sys/syscall_errno_windows.go | 6 +- .../imports/wasi_snapshot_preview1/fs.go | 13 +- .../engine/interpreter/interpreter.go | 3 + .../wazevo/backend/executable_context.go | 28 +- .../wazevo/backend/isa/amd64/machine.go | 16 +- .../engine/wazevo/backend/isa/arm64/abi.go | 30 +- .../backend/isa/arm64/abi_entry_preamble.go | 29 +- .../wazevo/backend/isa/arm64/abi_go_call.go | 119 ++--- .../engine/wazevo/backend/isa/arm64/instr.go | 438 +++++++++--------- .../backend/isa/arm64/instr_encoding.go | 136 +++--- .../backend/isa/arm64/lower_constant.go | 6 +- .../wazevo/backend/isa/arm64/lower_instr.go | 379 +++++++-------- .../wazevo/backend/isa/arm64/lower_mem.go | 59 ++- .../wazevo/backend/isa/arm64/machine.go | 17 +- .../isa/arm64/machine_pro_epi_logue.go | 51 +- .../backend/isa/arm64/machine_regalloc.go | 10 +- .../engine/wazevo/backend/regalloc.go | 12 +- .../wazevo/backend/regalloc/regalloc.go | 140 +++--- .../engine/wazevo/backend/regalloc/regset.go | 44 +- .../internal/engine/wazevo/call_engine.go | 18 - .../internal/engine/wazevo/engine_cache.go | 7 + .../engine/wazevo/frontend/frontend.go | 21 +- .../internal/engine/wazevo/frontend/lower.go | 12 +- .../internal/engine/wazevo/module_engine.go | 31 +- .../internal/engine/wazevo/ssa/basic_block.go | 73 +-- .../internal/engine/wazevo/ssa/builder.go | 104 +++-- .../wazero/internal/engine/wazevo/ssa/pass.go | 41 +- .../engine/wazevo/ssa/pass_blk_layouts.go | 16 +- .../internal/engine/wazevo/ssa/pass_cfg.go | 49 +- .../wazero/internal/engine/wazevo/ssa/type.go | 3 + .../internal/engine/wazevo/wazevoapi/pool.go | 4 +- .../wazero/internal/platform/cpuid.go | 5 + .../wazero/internal/platform/cpuid_amd64.go | 36 +- .../internal/platform/cpuid_unsupported.go | 9 +- .../wazero/internal/platform/mmap_unix.go | 2 - .../internal/platform/mmap_unsupported.go | 2 - .../wazero/internal/platform/mmap_windows.go | 2 - .../tetratelabs/wazero/internal/sysfs/file.go | 3 - .../wazero/internal/wasm/engine.go | 3 + .../wazero/internal/wasm/func_validation.go | 7 - .../wazero/internal/wasm/memory.go | 23 +- .../wazero/internal/wasm/module.go | 7 +- vendor/golang.org/x/crypto/acme/http.go | 21 +- .../golang.org/x/crypto/acme/version_go112.go | 27 -- vendor/golang.org/x/crypto/blake2s/blake2s.go | 10 +- .../golang.org/x/crypto/blake2s/register.go | 21 - vendor/golang.org/x/crypto/blowfish/cipher.go | 2 +- vendor/golang.org/x/crypto/cast5/cast5.go | 2 +- .../chacha20poly1305/chacha20poly1305.go | 2 +- .../x/crypto/curve25519/curve25519.go | 39 +- .../x/crypto/curve25519/curve25519_compat.go | 105 ----- .../x/crypto/curve25519/curve25519_go120.go | 46 -- .../x/crypto/curve25519/internal/field/README | 7 - .../x/crypto/curve25519/internal/field/fe.go | 416 ----------------- .../curve25519/internal/field/fe_amd64.go | 15 - .../curve25519/internal/field/fe_amd64.s | 378 --------------- .../internal/field/fe_amd64_noasm.go | 11 - .../curve25519/internal/field/fe_arm64.go | 15 - .../curve25519/internal/field/fe_arm64.s | 42 -- .../internal/field/fe_arm64_noasm.go | 11 - .../curve25519/internal/field/fe_generic.go | 264 ----------- .../curve25519/internal/field/sync.checkpoint | 1 - .../crypto/curve25519/internal/field/sync.sh | 19 - vendor/golang.org/x/crypto/ed25519/ed25519.go | 4 +- vendor/golang.org/x/crypto/hkdf/hkdf.go | 2 +- vendor/golang.org/x/crypto/md4/md4.go | 2 +- vendor/golang.org/x/crypto/nacl/box/box.go | 2 +- .../x/crypto/nacl/secretbox/secretbox.go | 2 +- .../x/crypto/openpgp/armor/armor.go | 5 +- .../x/crypto/openpgp/elgamal/elgamal.go | 2 +- .../x/crypto/openpgp/errors/errors.go | 2 +- .../x/crypto/openpgp/packet/packet.go | 2 +- vendor/golang.org/x/crypto/openpgp/s2k/s2k.go | 2 +- vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go | 2 +- .../x/crypto/poly1305/poly1305_compat.go | 2 +- .../x/crypto/salsa20/salsa/hsalsa20.go | 2 +- vendor/golang.org/x/crypto/scrypt/scrypt.go | 2 +- .../golang.org/x/crypto/ssh/agent/client.go | 2 +- vendor/golang.org/x/crypto/ssh/client_auth.go | 4 + vendor/golang.org/x/crypto/ssh/doc.go | 2 +- vendor/golang.org/x/sys/unix/mremap.go | 5 + .../golang.org/x/sys/unix/syscall_darwin.go | 12 + vendor/golang.org/x/sys/unix/syscall_unix.go | 9 + .../x/sys/unix/zsyscall_darwin_amd64.go | 33 ++ .../x/sys/unix/zsyscall_darwin_amd64.s | 10 + .../x/sys/unix/zsyscall_darwin_arm64.go | 33 ++ .../x/sys/unix/zsyscall_darwin_arm64.s | 10 + .../x/sys/windows/security_windows.go | 24 +- .../golang.org/x/sys/windows/svc/service.go | 5 +- .../x/sys/windows/zsyscall_windows.go | 9 + vendor/modules.txt | 14 +- 139 files changed, 2016 insertions(+), 2624 deletions(-) create mode 100644 vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_other.go create mode 100644 vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_slice.go rename vendor/github.com/ncruces/go-sqlite3/internal/{util/alloc.go => alloc/alloc_unix.go} (79%) create mode 100644 vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_windows.go create mode 100644 vendor/github.com/ncruces/go-sqlite3/registry.go delete mode 100644 vendor/github.com/ncruces/go-sqlite3/vfs/os_std_sleep.go create mode 100644 vendor/github.com/ncruces/go-sqlite3/vfs/shm_bsd.go delete mode 100644 vendor/golang.org/x/crypto/acme/version_go112.go delete mode 100644 vendor/golang.org/x/crypto/blake2s/register.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/curve25519_compat.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/curve25519_go120.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/README delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/fe.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.s delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.s delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/fe_generic.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint delete mode 100644 vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh diff --git a/go.mod b/go.mod index 81aaf530fc..5b05aa9335 100644 --- a/go.mod +++ b/go.mod @@ -34,7 +34,7 @@ require ( github.com/miekg/dns v1.1.59 github.com/moloch--/asciicast v0.1.0 github.com/moloch--/memmod v0.0.0-20230225130813-fd77d905589e - github.com/ncruces/go-sqlite3 v0.15.0 + github.com/ncruces/go-sqlite3 v0.17.1 github.com/reeflective/console v0.1.15 github.com/reeflective/readline v1.0.14 github.com/rsteube/carapace v0.46.3-0.20231214181515-27e49f3c3b69 @@ -42,16 +42,16 @@ require ( github.com/spf13/cobra v1.8.1 github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.9.0 - github.com/tetratelabs/wazero v1.7.2 + github.com/tetratelabs/wazero v1.7.3 github.com/things-go/go-socks5 v0.0.5 github.com/ulikunitz/xz v0.5.12 github.com/xlab/treeprint v1.2.0 github.com/yiya1989/sshkrb5 v0.0.1 - golang.org/x/crypto v0.24.0 + golang.org/x/crypto v0.25.0 golang.org/x/exp v0.0.0-20240416160154-fe59bbe5cc7f golang.org/x/net v0.25.0 - golang.org/x/sys v0.21.0 - golang.org/x/term v0.21.0 + golang.org/x/sys v0.22.0 + golang.org/x/term v0.22.0 golang.org/x/text v0.16.0 golang.zx2c4.com/wireguard v0.0.0-20231211153847-12269c276173 golang.zx2c4.com/wireguard/wgctrl v0.0.0-20230429144221-925a1e7659e6 diff --git a/go.sum b/go.sum index 26afaea86d..c4c8dedc48 100644 --- a/go.sum +++ b/go.sum @@ -303,8 +303,8 @@ github.com/moloch--/asciicast v0.1.0 h1:eBOJwuFKSk447s/kPs9MWsc4kAl5HmuKIDLDYD6/ github.com/moloch--/asciicast v0.1.0/go.mod h1:OckO16UDLgxVLclrCnbocL1ix15Br/8Xv/caBoYq98o= github.com/moloch--/memmod v0.0.0-20230225130813-fd77d905589e h1:IkFCPlAa0iTiLxck+NqAwBx8JDlnHYm4orOQBbs4BDQ= github.com/moloch--/memmod v0.0.0-20230225130813-fd77d905589e/go.mod h1:eYeI6cQ5YHhHt9i0BBW0zc1DaQnb4ZMXsSPuEV/V5Og= -github.com/ncruces/go-sqlite3 v0.15.0 h1:C+SIrcYsAIR5GUYWmCnif6x81n6BS9y75vYcQynuGNU= -github.com/ncruces/go-sqlite3 v0.15.0/go.mod h1:kHHYmFmK4G2VFFoIovEg9BEQ8BP+D81y4ESHXnzJV/w= +github.com/ncruces/go-sqlite3 v0.17.1 h1:VxTjDpCn87FaFlKMaAYC1jP7ND0d4UNj+6G4IQDHbgI= +github.com/ncruces/go-sqlite3 v0.17.1/go.mod h1:FnCyui8SlDoL0mQZ5dTouNo7s7jXS0kJv9lBt1GlM9w= github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M= @@ -387,8 +387,8 @@ github.com/tc-hib/winres v0.2.1 h1:YDE0FiP0VmtRaDn7+aaChp1KiF4owBiJa5l964l5ujA= github.com/tc-hib/winres v0.2.1/go.mod h1:C/JaNhH3KBvhNKVbvdlDWkbMDO9H4fKKDaN7/07SSuk= github.com/tcnksm/go-httpstat v0.2.0 h1:rP7T5e5U2HfmOBmZzGgGZjBQ5/GluWUylujl0tJ04I0= github.com/tcnksm/go-httpstat v0.2.0/go.mod h1:s3JVJFtQxtBEBC9dwcdTTXS9xFnM3SXAZwPG41aurT8= -github.com/tetratelabs/wazero v1.7.2 h1:1+z5nXJNwMLPAWaTePFi49SSTL0IMx/i3Fg8Yc25GDc= -github.com/tetratelabs/wazero v1.7.2/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y= +github.com/tetratelabs/wazero v1.7.3 h1:PBH5KVahrt3S2AHgEjKu4u+LlDbbk+nsGE3KLucy6Rw= +github.com/tetratelabs/wazero v1.7.3/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y= github.com/thedevsaddam/gojsonq/v2 v2.5.2 h1:CoMVaYyKFsVj6TjU6APqAhAvC07hTI6IQen8PHzHYY0= github.com/thedevsaddam/gojsonq/v2 v2.5.2/go.mod h1:bv6Xa7kWy82uT0LnXPE2SzGqTj33TAEeR560MdJkiXs= github.com/things-go/go-socks5 v0.0.5 h1:qvKaGcBkfDrUL33SchHN93srAmYGzb4CxSM2DPYufe8= @@ -427,8 +427,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI= -golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM= +golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30= +golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20240416160154-fe59bbe5cc7f h1:99ci1mjWVBWwJiEKYY6jWa4d2nTQVIEhZIptnrVb1XY= golang.org/x/exp v0.0.0-20240416160154-fe59bbe5cc7f/go.mod h1:/lliqkxwWAhPjf5oSOIJup2XcqJaw8RGS6k3TGEc7GI= @@ -498,12 +498,12 @@ golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.4.1-0.20230131160137-e7d7f63158de/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws= -golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI= +golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA= -golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0= +golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk= +golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= diff --git a/vendor/github.com/ncruces/go-sqlite3/README.md b/vendor/github.com/ncruces/go-sqlite3/README.md index 3cf5b4afe0..8cf9e7a812 100644 --- a/vendor/github.com/ncruces/go-sqlite3/README.md +++ b/vendor/github.com/ncruces/go-sqlite3/README.md @@ -33,6 +33,8 @@ Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ run provides the [`array`](https://sqlite.org/carray.html) table-valued function. - [`github.com/ncruces/go-sqlite3/ext/blobio`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blobio) simplifies [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html). +- [`github.com/ncruces/go-sqlite3/ext/bloom`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/bloom) + provides a [Bloom filter](https://github.com/nalgeon/sqlean/issues/27#issuecomment-1002267134) virtual table. - [`github.com/ncruces/go-sqlite3/ext/csv`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/csv) reads [comma-separated values](https://sqlite.org/csv.html). - [`github.com/ncruces/go-sqlite3/ext/fileio`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/fileio) @@ -43,20 +45,24 @@ Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ run reads data [line-by-line](https://github.com/asg017/sqlite-lines). - [`github.com/ncruces/go-sqlite3/ext/pivot`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/pivot) creates [pivot tables](https://github.com/jakethaw/pivot_vtab). +- [`github.com/ncruces/go-sqlite3/ext/regexp`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/regexp) + provides regular expression functions. - [`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. - [`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) + generates [UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier). - [`github.com/ncruces/go-sqlite3/ext/zorder`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/zorder) maps multidimensional data to one dimension. +- [`github.com/ncruces/go-sqlite3/vfs/adiantum`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/adiantum) + wraps a VFS to offer encryption at rest. - [`github.com/ncruces/go-sqlite3/vfs/memdb`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/memdb) implements an in-memory VFS. - [`github.com/ncruces/go-sqlite3/vfs/readervfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/readervfs) implements a VFS for immutable databases. -- [`github.com/ncruces/go-sqlite3/vfs/adiantum`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/adiantum) - wraps a VFS to offer encryption at rest. ### Advanced features @@ -88,7 +94,10 @@ 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](.github/workflows/test.yml) on -Linux (amd64/arm64/386/riscv64), macOS (amd64/arm64), Windows, FreeBSD and illumos. +Linux (amd64/arm64/386/riscv64/s390x), macOS (amd64/arm64), +Windows (amd64), FreeBSD (amd64), OpenBSD (amd64), NetBSD (amd64), +illumos (amd64), and Solaris (amd64). + The Go VFS is tested by running SQLite's [mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c). diff --git a/vendor/github.com/ncruces/go-sqlite3/conn.go b/vendor/github.com/ncruces/go-sqlite3/conn.go index 8ba034feef..39870b1400 100644 --- a/vendor/github.com/ncruces/go-sqlite3/conn.go +++ b/vendor/github.com/ncruces/go-sqlite3/conn.go @@ -72,6 +72,9 @@ func newConn(filename string, flags OpenFlag) (conn *Conn, err error) { c.arena = c.newArena(1024) c.ctx = context.WithValue(c.ctx, connKey{}, c) c.handle, err = c.openDB(filename, flags) + if err == nil { + err = initExtensions(c) + } if err != nil { return nil, err } @@ -346,10 +349,9 @@ func (c *Conn) checkInterrupt() { } func progressCallback(ctx context.Context, mod api.Module, pDB uint32) (interrupt uint32) { - if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.interrupt != nil { - if c.interrupt.Err() != nil { - interrupt = 1 - } + if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && + c.interrupt != nil && c.interrupt.Err() != nil { + interrupt = 1 } return interrupt } @@ -363,6 +365,30 @@ func (c *Conn) BusyTimeout(timeout time.Duration) error { return c.error(r) } +func timeoutCallback(ctx context.Context, mod api.Module, pDB uint32, count, tmout int32) (retry uint32) { + if c, ok := ctx.Value(connKey{}).(*Conn); ok && + (c.interrupt == nil || c.interrupt.Err() == nil) { + const delays = "\x01\x02\x05\x0a\x0f\x14\x19\x19\x19\x32\x32\x64" + const totals = "\x00\x01\x03\x08\x12\x21\x35\x4e\x67\x80\xb2\xe4" + const ndelay = int32(len(delays) - 1) + + var delay, prior int32 + if count <= ndelay { + delay = int32(delays[count]) + prior = int32(totals[count]) + } else { + delay = int32(delays[ndelay]) + prior = int32(totals[ndelay]) + delay*(count-ndelay) + } + + if delay = min(delay, tmout-prior); delay > 0 { + time.Sleep(time.Duration(delay) * time.Millisecond) + retry = 1 + } + } + return retry +} + // BusyHandler registers a callback to handle [BUSY] errors. // // https://sqlite.org/c3ref/busy_handler.html @@ -380,7 +406,8 @@ func (c *Conn) BusyHandler(cb func(count int) (retry bool)) error { } func busyCallback(ctx context.Context, mod api.Module, pDB uint32, count int32) (retry uint32) { - if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.busy != nil { + if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.busy != nil && + (c.interrupt == nil || c.interrupt.Err() == nil) { if c.busy(int(count)) { retry = 1 } diff --git a/vendor/github.com/ncruces/go-sqlite3/driver/driver.go b/vendor/github.com/ncruces/go-sqlite3/driver/driver.go index b496f76ec6..e7863b1b8f 100644 --- a/vendor/github.com/ncruces/go-sqlite3/driver/driver.go +++ b/vendor/github.com/ncruces/go-sqlite3/driver/driver.go @@ -229,6 +229,7 @@ func (c *conn) Raw() *sqlite3.Conn { return c.Conn } +// Deprecated: use BeginTx instead. func (c *conn) Begin() (driver.Tx, error) { return c.BeginTx(context.Background(), driver.TxOptions{}) } @@ -301,7 +302,7 @@ func (c *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, e s.Close() return nil, util.TailErr } - return &stmt{Stmt: s, tmRead: c.tmRead, tmWrite: c.tmWrite}, nil + return &stmt{Stmt: s, tmRead: c.tmRead, tmWrite: c.tmWrite, inputs: -2}, nil } func (c *conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) { @@ -335,6 +336,7 @@ type stmt struct { *sqlite3.Stmt tmWrite sqlite3.TimeFormat tmRead sqlite3.TimeFormat + inputs int } var ( @@ -345,12 +347,17 @@ var ( ) func (s *stmt) NumInput() int { + if s.inputs >= -1 { + return s.inputs + } n := s.Stmt.BindCount() for i := 1; i <= n; i++ { if s.Stmt.BindName(i) != "" { + s.inputs = -1 return -1 } } + s.inputs = n return n } @@ -389,12 +396,7 @@ func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driv return &rows{ctx: ctx, stmt: s}, nil } -func (s *stmt) setupBindings(args []driver.NamedValue) error { - err := s.Stmt.ClearBindings() - if err != nil { - return err - } - +func (s *stmt) setupBindings(args []driver.NamedValue) (err error) { var ids [3]int for _, arg := range args { ids := ids[:0] @@ -558,19 +560,20 @@ func (r *rows) Next(dest []driver.Value) error { return err } -func (r *rows) decodeTime(i int, v any) (_ time.Time, _ bool) { +func (r *rows) decodeTime(i int, v any) (_ time.Time, ok bool) { if r.tmRead == sqlite3.TimeFormatDefault { + // handled by maybeTime return } - switch r.declType(i) { - case "DATE", "TIME", "DATETIME", "TIMESTAMP": - // maybe + switch v.(type) { + case int64, float64, string: + // could be a time value default: return } - switch v.(type) { - case int64, float64, string: - // maybe + switch r.declType(i) { + case "DATE", "TIME", "DATETIME", "TIMESTAMP": + // could be a time value default: return } diff --git a/vendor/github.com/ncruces/go-sqlite3/embed/README.md b/vendor/github.com/ncruces/go-sqlite3/embed/README.md index 87281a83f8..0156f01763 100644 --- a/vendor/github.com/ncruces/go-sqlite3/embed/README.md +++ b/vendor/github.com/ncruces/go-sqlite3/embed/README.md @@ -1,6 +1,6 @@ # Embeddable Wasm build of SQLite -This folder includes an embeddable Wasm build of SQLite 3.45.3 for use with +This folder includes an embeddable Wasm build of SQLite 3.46.0 for use with [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3). The following optional features are compiled in: @@ -10,6 +10,7 @@ The following optional features are compiled in: - [R*Tree](https://sqlite.org/rtree.html) - [GeoPoly](https://sqlite.org/geopoly.html) - [soundex](https://sqlite.org/lang_corefunc.html#soundex) +- [stat4](https://sqlite.org/compile.html#enable_stat4) - [base64](https://github.com/sqlite/sqlite/blob/master/ext/misc/base64.c) - [decimal](https://github.com/sqlite/sqlite/blob/master/ext/misc/decimal.c) - [ieee754](https://github.com/sqlite/sqlite/blob/master/ext/misc/ieee754.c) @@ -23,4 +24,7 @@ See the [configuration options](../sqlite3/sqlite_cfg.h), and [patches](../sqlite3) applied. Built using [`wasi-sdk`](https://github.com/WebAssembly/wasi-sdk), -and [`binaryen`](https://github.com/WebAssembly/binaryen). \ No newline at end of file +and [`binaryen`](https://github.com/WebAssembly/binaryen). + +The build is easily reproducible, and verifiable, using +[Artifact Attestations](https://github.com/ncruces/go-sqlite3/attestations). \ No newline at end of file diff --git a/vendor/github.com/ncruces/go-sqlite3/embed/build.sh b/vendor/github.com/ncruces/go-sqlite3/embed/build.sh index c50112c0bf..8ea380e269 100644 --- a/vendor/github.com/ncruces/go-sqlite3/embed/build.sh +++ b/vendor/github.com/ncruces/go-sqlite3/embed/build.sh @@ -7,8 +7,8 @@ ROOT=../ BINARYEN="$ROOT/tools/binaryen-version_117/bin" WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin" -"$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \ - -Wall -Wextra -Wno-unused-parameter \ +"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -flto -g0 -O2 \ + -Wall -Wextra -Wno-unused-parameter -Wno-unused-function \ -o sqlite3.wasm "$ROOT/sqlite3/main.c" \ -I"$ROOT/sqlite3" \ -mexec-model=reactor \ @@ -20,6 +20,7 @@ WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin" -Wl,--stack-first \ -Wl,--import-undefined \ -D_HAVE_SQLITE_CONFIG_H \ + -DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \ $(awk '{print "-Wl,--export="$0}' exports.txt) trap 'rm -f sqlite3.tmp' EXIT diff --git a/vendor/github.com/ncruces/go-sqlite3/embed/exports.txt b/vendor/github.com/ncruces/go-sqlite3/embed/exports.txt index da16316bbe..b3cb1581c9 100644 --- a/vendor/github.com/ncruces/go-sqlite3/embed/exports.txt +++ b/vendor/github.com/ncruces/go-sqlite3/embed/exports.txt @@ -36,10 +36,13 @@ sqlite3_collation_needed_go sqlite3_column_blob sqlite3_column_bytes sqlite3_column_count +sqlite3_column_database_name sqlite3_column_decltype sqlite3_column_double sqlite3_column_int64 sqlite3_column_name +sqlite3_column_origin_name +sqlite3_column_table_name sqlite3_column_text sqlite3_column_type sqlite3_column_value diff --git a/vendor/github.com/ncruces/go-sqlite3/embed/sqlite3.wasm b/vendor/github.com/ncruces/go-sqlite3/embed/sqlite3.wasm index 2f36b2948d459958509396948142e5ce19a25291..43a1f99ad985cd9513daa5a74d1fd526be8f526e 100644 GIT binary patch delta 463888 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

#7?Cbg{ZMpSVVS94d{E$rMGo^>2|zto61Yqp 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 M_vEYc8h6zH0Up09-~a#s delta 439912 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 B4aWg@~MOZqb3Z(?VTACldEu@ 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%0A8rmw7_z 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%0AkFv`L;RzC^}?@gz7rf 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 cap { + b.buf = append(b.buf[:cap], make([]byte, size-cap)...) + } else { + b.buf = b.buf[:size] + } + return b.buf +} diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/alloc.go b/vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_unix.go similarity index 79% rename from vendor/github.com/ncruces/go-sqlite3/internal/util/alloc.go rename to vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_unix.go index 23c5382375..39a3a38ccf 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/alloc.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_unix.go @@ -1,6 +1,6 @@ -//go:build unix +//go:build unix && !sqlite3_nosys -package util +package alloc import ( "math" @@ -9,30 +9,24 @@ import ( "golang.org/x/sys/unix" ) -func mmappedAllocator(cap, max uint64) experimental.LinearMemory { +func Virtual(_, max uint64) experimental.LinearMemory { // Round up to the page size. rnd := uint64(unix.Getpagesize() - 1) max = (max + rnd) &^ rnd - cap = (cap + rnd) &^ rnd if max > math.MaxInt { // This ensures int(max) overflows to a negative value, // and unix.Mmap returns EINVAL. max = math.MaxUint64 } + // Reserve max bytes of address space, to ensure we won't need to move it. // A protected, private, anonymous mapping should not commit memory. b, err := unix.Mmap(-1, 0, int(max), unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_ANON) if err != nil { panic(err) } - // Commit the initial cap bytes of memory. - err = unix.Mprotect(b[:cap], unix.PROT_READ|unix.PROT_WRITE) - if err != nil { - unix.Munmap(b) - panic(err) - } - return &mmappedMemory{buf: b[:cap]} + return &mmappedMemory{buf: b[:0]} } // The slice covers the entire mmapped memory: @@ -43,7 +37,9 @@ type mmappedMemory struct { } func (m *mmappedMemory) Reallocate(size uint64) []byte { - if com := uint64(len(m.buf)); com < size { + com := uint64(len(m.buf)) + res := uint64(cap(m.buf)) + if com < size && size < res { // Round up to the page size. rnd := uint64(unix.Getpagesize() - 1) new := (size + rnd) &^ rnd diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_windows.go b/vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_windows.go new file mode 100644 index 0000000000..27d875f2e3 --- /dev/null +++ b/vendor/github.com/ncruces/go-sqlite3/internal/alloc/alloc_windows.go @@ -0,0 +1,76 @@ +//go:build !sqlite3_nosys + +package alloc + +import ( + "math" + "reflect" + "unsafe" + + "github.com/tetratelabs/wazero/experimental" + "golang.org/x/sys/windows" +) + +func Virtual(_, max uint64) experimental.LinearMemory { + // Round up to the page size. + rnd := uint64(windows.Getpagesize() - 1) + max = (max + rnd) &^ rnd + + if max > math.MaxInt { + // This ensures uintptr(max) overflows to a large value, + // and windows.VirtualAlloc returns an error. + max = math.MaxUint64 + } + + // Reserve max bytes of address space, to ensure we won't need to move it. + // This does not commit memory. + r, err := windows.VirtualAlloc(0, uintptr(max), windows.MEM_RESERVE, windows.PAGE_READWRITE) + if err != nil { + panic(err) + } + + mem := virtualMemory{addr: r} + // SliceHeader, although deprecated, avoids a go vet warning. + sh := (*reflect.SliceHeader)(unsafe.Pointer(&mem.buf)) + sh.Cap = int(max) + sh.Data = r + return &mem +} + +// The slice covers the entire mmapped memory: +// - len(buf) is the already committed memory, +// - cap(buf) is the reserved address space. +type virtualMemory struct { + buf []byte + addr uintptr +} + +func (m *virtualMemory) Reallocate(size uint64) []byte { + com := uint64(len(m.buf)) + res := uint64(cap(m.buf)) + if com < size && size < res { + // Round up to the page size. + rnd := uint64(windows.Getpagesize() - 1) + new := (size + rnd) &^ rnd + + // Commit additional memory up to new bytes. + _, err := windows.VirtualAlloc(m.addr, uintptr(new), windows.MEM_COMMIT, windows.PAGE_READWRITE) + if err != nil { + panic(err) + } + + // Update committed memory. + m.buf = m.buf[:new] + } + // Limit returned capacity because bytes beyond + // len(m.buf) have not yet been committed. + return m.buf[:size:len(m.buf)] +} + +func (m *virtualMemory) Free() { + err := windows.VirtualFree(m.addr, 0, windows.MEM_RELEASE) + if err != nil { + panic(err) + } + m.addr = 0 +} diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/const.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/const.go index 86bb9749db..5e89018ddf 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/const.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/const.go @@ -1,6 +1,6 @@ package util -// https://sqlite.com/matrix/rescode.html +// https://sqlite.com/rescode.html const ( OK = 0 /* Successful result */ diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/error.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/error.go index 1f5555fd3e..2aecac96e6 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/error.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/error.go @@ -104,3 +104,13 @@ func ErrorCodeString(rc uint32) string { } return "sqlite3: unknown error" } + +type ErrorJoiner []error + +func (j *ErrorJoiner) Join(errs ...error) { + for _, err := range errs { + if err != nil { + *j = append(*j, err) + } + } +} diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/json.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/json.go index c0ba38cf05..7f6849a429 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/json.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/json.go @@ -26,7 +26,7 @@ func (j JSON) Scan(value any) error { buf = v.AppendFormat(buf, time.RFC3339Nano) buf = append(buf, '"') case nil: - buf = append(buf, "null"...) + buf = []byte("null") default: panic(AssertErr()) } diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/mmap.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/mmap.go index 26f30beaa8..434cc12adc 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/mmap.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/mmap.go @@ -1,4 +1,4 @@ -//go:build (darwin || linux) && (amd64 || arm64 || riscv64) && !(sqlite3_flock || sqlite3_noshm || sqlite3_nosys) +//go:build unix && (amd64 || arm64 || riscv64) && !(sqlite3_noshm || sqlite3_nosys) package util @@ -7,14 +7,15 @@ import ( "os" "unsafe" + "github.com/ncruces/go-sqlite3/internal/alloc" "github.com/tetratelabs/wazero/api" "github.com/tetratelabs/wazero/experimental" "golang.org/x/sys/unix" ) -func withMmappedAllocator(ctx context.Context) context.Context { +func withAllocator(ctx context.Context) context.Context { return experimental.WithMemoryAllocator(ctx, - experimental.MemoryAllocatorFunc(mmappedAllocator)) + experimental.MemoryAllocatorFunc(alloc.Virtual)) } type mmapState struct { @@ -45,7 +46,7 @@ func (s *mmapState) new(ctx context.Context, mod api.Module, size int32) *Mapped // Save the newly allocated region. ptr := uint32(stack[0]) buf := View(mod, ptr, uint64(size)) - addr := uintptr(unsafe.Pointer(&buf[0])) + addr := unsafe.Pointer(&buf[0]) s.regions = append(s.regions, &MappedRegion{ Ptr: ptr, addr: addr, @@ -55,7 +56,7 @@ func (s *mmapState) new(ctx context.Context, mod api.Module, size int32) *Mapped } type MappedRegion struct { - addr uintptr + addr unsafe.Pointer Ptr uint32 size int32 used bool @@ -75,23 +76,15 @@ func (r *MappedRegion) Unmap() error { // We can't munmap the region, otherwise it could be remaped. // Instead, convert it to a protected, private, anonymous mapping. // If successful, it can be reused for a subsequent mmap. - _, err := mmap(r.addr, uintptr(r.size), - unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_ANON|unix.MAP_FIXED, - -1, 0) + _, err := unix.MmapPtr(-1, 0, r.addr, uintptr(r.size), + unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_FIXED|unix.MAP_ANON) r.used = err != nil return err } func (r *MappedRegion) mmap(f *os.File, offset int64, prot int) error { - _, err := mmap(r.addr, uintptr(r.size), - prot, unix.MAP_SHARED|unix.MAP_FIXED, - int(f.Fd()), offset) + _, err := unix.MmapPtr(int(f.Fd()), offset, r.addr, uintptr(r.size), + prot, unix.MAP_SHARED|unix.MAP_FIXED) r.used = err == nil return err } - -// We need the low level mmap for MAP_FIXED to work. -// Bind the syscall version hoping that it is more stable. - -//go:linkname mmap syscall.mmap -func mmap(addr, length uintptr, prot, flag, fd int, pos int64) (*byte, error) diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/mmap_other.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/mmap_other.go index 89631e0939..a0a3ba67d4 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/mmap_other.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/mmap_other.go @@ -1,11 +1,22 @@ -//go:build !(darwin || linux) || !(amd64 || arm64 || riscv64) || sqlite3_flock || sqlite3_noshm || sqlite3_nosys +//go:build !unix || !(amd64 || arm64 || riscv64) || sqlite3_noshm || sqlite3_nosys package util -import "context" +import ( + "context" + + "github.com/ncruces/go-sqlite3/internal/alloc" + "github.com/tetratelabs/wazero/experimental" +) type mmapState struct{} -func withMmappedAllocator(ctx context.Context) context.Context { - return ctx +func withAllocator(ctx context.Context) context.Context { + return experimental.WithMemoryAllocator(ctx, + experimental.MemoryAllocatorFunc(func(cap, max uint64) experimental.LinearMemory { + if cap == max { + return alloc.Virtual(cap, max) + } + return alloc.Slice(cap, max) + })) } diff --git a/vendor/github.com/ncruces/go-sqlite3/internal/util/module.go b/vendor/github.com/ncruces/go-sqlite3/internal/util/module.go index 20b17b2097..22793e972e 100644 --- a/vendor/github.com/ncruces/go-sqlite3/internal/util/module.go +++ b/vendor/github.com/ncruces/go-sqlite3/internal/util/module.go @@ -14,7 +14,7 @@ type moduleState struct { func NewContext(ctx context.Context) context.Context { state := new(moduleState) - ctx = withMmappedAllocator(ctx) + ctx = withAllocator(ctx) ctx = experimental.WithCloseNotifier(ctx, state) ctx = context.WithValue(ctx, moduleKey{}, state) return ctx diff --git a/vendor/github.com/ncruces/go-sqlite3/json.go b/vendor/github.com/ncruces/go-sqlite3/json.go index 9b2565e87c..2b762c092f 100644 --- a/vendor/github.com/ncruces/go-sqlite3/json.go +++ b/vendor/github.com/ncruces/go-sqlite3/json.go @@ -5,7 +5,8 @@ import "github.com/ncruces/go-sqlite3/internal/util" // JSON returns a value that can be used as an argument to // [database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to // store value as JSON, or decode JSON into value. -// JSON should NOT be used with [BindJSON] or [ResultJSON]. +// JSON should NOT be used with [Stmt.BindJSON], [Stmt.ColumnJSON], +// [Value.JSON], or [Context.ResultJSON]. func JSON(value any) any { return util.JSON{Value: value} } diff --git a/vendor/github.com/ncruces/go-sqlite3/pointer.go b/vendor/github.com/ncruces/go-sqlite3/pointer.go index 611c1528ce..0e2418b992 100644 --- a/vendor/github.com/ncruces/go-sqlite3/pointer.go +++ b/vendor/github.com/ncruces/go-sqlite3/pointer.go @@ -4,7 +4,8 @@ import "github.com/ncruces/go-sqlite3/internal/util" // Pointer returns a pointer to a value that can be used as an argument to // [database/sql.DB.Exec] and similar methods. -// Pointer should NOT be used with [BindPointer] or [ResultPointer]. +// Pointer should NOT be used with [Stmt.BindPointer], +// [Value.Pointer], or [Context.ResultPointer]. // // https://sqlite.org/bindptr.html func Pointer[T any](value T) any { diff --git a/vendor/github.com/ncruces/go-sqlite3/registry.go b/vendor/github.com/ncruces/go-sqlite3/registry.go new file mode 100644 index 0000000000..043d69eeb5 --- /dev/null +++ b/vendor/github.com/ncruces/go-sqlite3/registry.go @@ -0,0 +1,30 @@ +package sqlite3 + +import "sync" + +var ( + // +checklocks:extRegistryMtx + extRegistry []func(*Conn) error + extRegistryMtx sync.RWMutex +) + +// AutoExtension causes the entryPoint function to be invoked +// for each new database connection that is created. +// +// https://sqlite.org/c3ref/auto_extension.html +func AutoExtension(entryPoint func(*Conn) error) { + extRegistryMtx.Lock() + defer extRegistryMtx.Unlock() + extRegistry = append(extRegistry, entryPoint) +} + +func initExtensions(c *Conn) error { + extRegistryMtx.RLock() + defer extRegistryMtx.RUnlock() + for _, f := range extRegistry { + if err := f(c); err != nil { + return err + } + } + return nil +} diff --git a/vendor/github.com/ncruces/go-sqlite3/sqlite.go b/vendor/github.com/ncruces/go-sqlite3/sqlite.go index a446ec0d1e..61a03652fd 100644 --- a/vendor/github.com/ncruces/go-sqlite3/sqlite.go +++ b/vendor/github.com/ncruces/go-sqlite3/sqlite.go @@ -28,6 +28,14 @@ var ( RuntimeConfig wazero.RuntimeConfig ) +// Initialize decodes and compiles the SQLite Wasm binary. +// This is called implicitly when the first connection is openned, +// but is potentially slow, so you may want to call it at a more convenient time. +func Initialize() error { + instance.once.Do(compileSQLite) + return instance.err +} + var instance struct { runtime wazero.Runtime compiled wazero.CompiledModule @@ -79,9 +87,8 @@ type sqlite struct { } func instantiateSQLite() (sqlt *sqlite, err error) { - instance.once.Do(compileSQLite) - if instance.err != nil { - return nil, instance.err + if err := Initialize(); err != nil { + return nil, err } sqlt = new(sqlite) @@ -289,8 +296,9 @@ func (a *arena) string(s string) uint32 { } func exportCallbacks(env wazero.HostModuleBuilder) wazero.HostModuleBuilder { - util.ExportFuncIII(env, "go_busy_handler", busyCallback) util.ExportFuncII(env, "go_progress_handler", progressCallback) + util.ExportFuncIIII(env, "go_busy_timeout", timeoutCallback) + util.ExportFuncIII(env, "go_busy_handler", busyCallback) util.ExportFuncII(env, "go_commit_hook", commitCallback) util.ExportFuncVI(env, "go_rollback_hook", rollbackCallback) util.ExportFuncVIIIIJ(env, "go_update_hook", updateCallback) diff --git a/vendor/github.com/ncruces/go-sqlite3/stmt.go b/vendor/github.com/ncruces/go-sqlite3/stmt.go index fc26b1e95e..381a7d06ba 100644 --- a/vendor/github.com/ncruces/go-sqlite3/stmt.go +++ b/vendor/github.com/ncruces/go-sqlite3/stmt.go @@ -367,12 +367,10 @@ func (s *Stmt) ColumnCount() int { func (s *Stmt) ColumnName(col int) string { r := s.c.call("sqlite3_column_name", uint64(s.handle), uint64(col)) - - ptr := uint32(r) - if ptr == 0 { + if r == 0 { panic(util.OOMErr) } - return util.ReadString(s.c.mod, ptr, _MAX_NAME) + return util.ReadString(s.c.mod, uint32(r), _MAX_NAME) } // ColumnType returns the initial [Datatype] of the result column. @@ -398,15 +396,57 @@ func (s *Stmt) ColumnDeclType(col int) string { return util.ReadString(s.c.mod, uint32(r), _MAX_NAME) } +// ColumnDatabaseName returns the name of the database +// that is the origin of a particular result column. +// The leftmost column of the result set has the index 0. +// +// https://sqlite.org/c3ref/column_database_name.html +func (s *Stmt) ColumnDatabaseName(col int) string { + r := s.c.call("sqlite3_column_database_name", + uint64(s.handle), uint64(col)) + if r == 0 { + return "" + } + return util.ReadString(s.c.mod, uint32(r), _MAX_NAME) +} + +// ColumnTableName returns the name of the table +// that is the origin of a particular result column. +// The leftmost column of the result set has the index 0. +// +// https://sqlite.org/c3ref/column_database_name.html +func (s *Stmt) ColumnTableName(col int) string { + r := s.c.call("sqlite3_column_table_name", + uint64(s.handle), uint64(col)) + if r == 0 { + return "" + } + return util.ReadString(s.c.mod, uint32(r), _MAX_NAME) +} + +// ColumnOriginName returns the name of the table column +// that is the origin of a particular result column. +// The leftmost column of the result set has the index 0. +// +// https://sqlite.org/c3ref/column_database_name.html +func (s *Stmt) ColumnOriginName(col int) string { + r := s.c.call("sqlite3_column_origin_name", + uint64(s.handle), uint64(col)) + if r == 0 { + return "" + } + return util.ReadString(s.c.mod, uint32(r), _MAX_NAME) +} + // ColumnBool returns the value of the result column as a bool. // The leftmost column of the result set has the index 0. // SQLite does not have a separate boolean storage class. -// Instead, boolean values are retrieved as integers, +// Instead, boolean values are retrieved as numbers, // with 0 converted to false and any other value to true. // // https://sqlite.org/c3ref/column_blob.html func (s *Stmt) ColumnBool(col int) bool { - return s.ColumnInt64(col) != 0 + return s.ColumnFloat(col) != 0 } // ColumnInt returns the value of the result column as an int. @@ -524,7 +564,7 @@ func (s *Stmt) ColumnJSON(col int, ptr any) error { var data []byte switch s.ColumnType(col) { case NULL: - data = append(data, "null"...) + data = []byte("null") case TEXT: data = s.ColumnRawText(col) case BLOB: diff --git a/vendor/github.com/ncruces/go-sqlite3/time.go b/vendor/github.com/ncruces/go-sqlite3/time.go index a14870ea54..0164a307b6 100644 --- a/vendor/github.com/ncruces/go-sqlite3/time.go +++ b/vendor/github.com/ncruces/go-sqlite3/time.go @@ -101,7 +101,7 @@ func (f TimeFormat) Encode(t time.Time) any { return t.UnixMicro() case TimeFormatUnixNano: return t.UnixNano() - // Special formats + // Special formats. case TimeFormatDefault, TimeFormatAuto: f = time.RFC3339Nano // SQLite assumes UTC if unspecified. @@ -139,7 +139,7 @@ func (f TimeFormat) Encode(t time.Time) any { // https://sqlite.org/lang_datefunc.html func (f TimeFormat) Decode(v any) (time.Time, error) { switch f { - // Numeric formats + // Numeric formats. case TimeFormatJulianDay: switch v := v.(type) { case string: @@ -183,7 +183,7 @@ func (f TimeFormat) Decode(v any) (time.Time, error) { case float64: return time.UnixMilli(int64(math.Floor(v))).UTC(), nil case int64: - return time.UnixMilli(int64(v)).UTC(), nil + return time.UnixMilli(v).UTC(), nil default: return time.Time{}, util.TimeErr } @@ -200,7 +200,7 @@ func (f TimeFormat) Decode(v any) (time.Time, error) { case float64: return time.UnixMicro(int64(math.Floor(v))).UTC(), nil case int64: - return time.UnixMicro(int64(v)).UTC(), nil + return time.UnixMicro(v).UTC(), nil default: return time.Time{}, util.TimeErr } @@ -217,12 +217,12 @@ func (f TimeFormat) Decode(v any) (time.Time, error) { case float64: return time.Unix(0, int64(math.Floor(v))).UTC(), nil case int64: - return time.Unix(0, int64(v)).UTC(), nil + return time.Unix(0, v).UTC(), nil default: return time.Time{}, util.TimeErr } - // Special formats + // Special formats. case TimeFormatAuto: switch s := v.(type) { case string: diff --git a/vendor/github.com/ncruces/go-sqlite3/value.go b/vendor/github.com/ncruces/go-sqlite3/value.go index 61d3cbf709..1894ff4f10 100644 --- a/vendor/github.com/ncruces/go-sqlite3/value.go +++ b/vendor/github.com/ncruces/go-sqlite3/value.go @@ -68,12 +68,12 @@ func (v Value) NumericType() Datatype { // Bool returns the value as a bool. // SQLite does not have a separate boolean storage class. -// Instead, boolean values are retrieved as integers, +// Instead, boolean values are retrieved as numbers, // with 0 converted to false and any other value to true. // // https://sqlite.org/c3ref/value_blob.html func (v Value) Bool() bool { - return v.Int64() != 0 + return v.Float() != 0 } // Int returns the value as an int. @@ -177,7 +177,7 @@ func (v Value) JSON(ptr any) error { var data []byte switch v.Type() { case NULL: - data = append(data, "null"...) + data = []byte("null") case TEXT: data = v.RawText() case BLOB: diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/README.md b/vendor/github.com/ncruces/go-sqlite3/vfs/README.md index 212ad6d335..741a1b6a49 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/README.md +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/README.md @@ -2,15 +2,14 @@ This package implements the SQLite [OS Interface](https://sqlite.org/vfs.html) (aka VFS). -It replaces the default SQLite VFS with a **pure Go** implementation. - -It also exposes [interfaces](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#VFS) +It replaces the default SQLite VFS with a **pure Go** implementation, +and exposes [interfaces](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#VFS) that should allow you to implement your own custom VFSes. Since it is a from scratch reimplementation, there are naturally some ways it deviates from the original. -The main differences are [file locking](#file-locking) and [WAL mode](write-ahead-logging) support. +The main differences are [file locking](#file-locking) and [WAL mode](#write-ahead-logging) support. ### File Locking @@ -22,58 +21,72 @@ On Linux and macOS, this module uses to synchronize access to database files. OFD locks are fully compatible with POSIX advisory locks. -On BSD Unixes, this module uses -[BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2). -On BSD, these locks are fully compatible with POSIX advisory locks. -However, concurrency is reduced with BSD locks -(`BEGIN IMMEDIATE` behaves the same as `BEGIN EXCLUSIVE`). +This module can also use +[BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2), +albeit with reduced concurrency (`BEGIN IMMEDIATE` behaves like `BEGIN EXCLUSIVE`). +On BSD, macOS, and illumos, BSD locks are fully compatible with POSIX advisory locks; +on Linux and z/OS, they are fully functional, but incompatible; +elsewhere, they are very likely broken. +BSD locks are the default on BSD and illumos, +but you can opt into them with the `sqlite3_flock` build tag. On Windows, this module uses `LockFileEx` and `UnlockFileEx`, like SQLite. -On all other platforms, file locking is not supported, and you must use +Otherwise, file locking is not supported, and you must use [`nolock=1`](https://sqlite.org/uri.html#urinolock) (or [`immutable=1`](https://sqlite.org/uri.html#uriimmutable)) -to open database files.\ +to open database files. To use the [`database/sql`](https://pkg.go.dev/database/sql) driver with `nolock=1` you must disable connection pooling by calling [`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns). You can use [`vfs.SupportsFileLocking`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#SupportsFileLocking) -to check if your platform supports file locking. +to check if your build supports file locking. ### Write-Ahead Logging -On 64-bit Linux and macOS, this module uses `mmap` to implement +On 64-bit Unix, this module uses `mmap` to implement [shared-memory for the WAL-index](https://sqlite.org/wal.html#implementation_of_shared_memory_for_the_wal_index), like SQLite. -To allow `mmap` to work, each connection needs to reserve up to 4GB of address space.\ -To limit the amount of address space each connection needs, +To allow `mmap` to work, each connection needs to reserve up to 4GB of address space. +To limit the address space each connection reserves, use [`WithMemoryLimitPages`](../tests/testcfg/testcfg.go). -On Windows and BSD, [WAL](https://sqlite.org/wal.html) support is -[limited](https://sqlite.org/wal.html#noshm). -`EXCLUSIVE` locking mode can be set to create, read, and write WAL databases.\ +With [BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2) +a WAL database can only be accessed by a single proccess. +Other processes that attempt to access a database locked with BSD locks, +will fail with the `SQLITE_PROTOCOL` error code. + +Otherwise, [WAL support is limited](https://sqlite.org/wal.html#noshm), +and `EXCLUSIVE` locking mode must be set to create, read, and write WAL databases. To use `EXCLUSIVE` locking mode with the [`database/sql`](https://pkg.go.dev/database/sql) driver you must disable connection pooling by calling [`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns). -On all other platforms, where file locking is not supported, WAL mode does not work. - You can use [`vfs.SupportsSharedMemory`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#SupportsSharedMemory) -to check if your platform supports shared memory. +to check if your build supports shared memory. ### Batch-Atomic Write On 64-bit Linux, this module supports [batch-atomic writes](https://sqlite.org/cgi/src/technote/714) -with the F2FS filesystem. +on the F2FS filesystem. -### Build tags +### Build Tags The VFS can be customized with a few build tags: -- `sqlite3_flock` forces the use of BSD locks; it can be used on macOS to test the BSD locking implementation. +- `sqlite3_flock` forces the use of BSD locks; it can be used on z/OS to enable locking, + and elsewhere to test BSD locks. - `sqlite3_nosys` prevents importing [`x/sys`](https://pkg.go.dev/golang.org/x/sys); disables locking _and_ shared memory on all platforms. - `sqlite3_noshm` disables shared memory on all platforms. + +> [!IMPORTANT] +> The default configuration of this package is compatible with the standard +> [Unix and Windows SQLite VFSes](https://sqlite.org/vfs.html#multiple_vfses); +> `sqlite3_flock` builds are compatible with the +> [`unix-flock` VFS](https://sqlite.org/compile.html#enable_locking_style). +> If incompatible file locking is used, accessing databases concurrently with +> _other_ SQLite libraries will eventually corrupt data. diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/api.go b/vendor/github.com/ncruces/go-sqlite3/vfs/api.go index 19c22ae8fa..e133e8be92 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/api.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/api.go @@ -168,8 +168,8 @@ type FileSharedMemory interface { // SharedMemory is a shared-memory WAL-index implementation. // Use [NewSharedMemory] to create a shared-memory. type SharedMemory interface { - shmMap(context.Context, api.Module, int32, int32, bool) (uint32, error) - shmLock(int32, int32, _ShmFlag) error + shmMap(context.Context, api.Module, int32, int32, bool) (uint32, _ErrorCode) + shmLock(int32, int32, _ShmFlag) _ErrorCode shmUnmap(bool) io.Closer } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/const.go b/vendor/github.com/ncruces/go-sqlite3/vfs/const.go index 7f409f35f4..2fc934f336 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/const.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/const.go @@ -47,9 +47,11 @@ const ( _IOERR_SHMMAP _ErrorCode = util.IOERR_SHMMAP _IOERR_SEEK _ErrorCode = util.IOERR_SEEK _IOERR_DELETE_NOENT _ErrorCode = util.IOERR_DELETE_NOENT + _IOERR_GETTEMPPATH _ErrorCode = util.IOERR_GETTEMPPATH _IOERR_BEGIN_ATOMIC _ErrorCode = util.IOERR_BEGIN_ATOMIC _IOERR_COMMIT_ATOMIC _ErrorCode = util.IOERR_COMMIT_ATOMIC _IOERR_ROLLBACK_ATOMIC _ErrorCode = util.IOERR_ROLLBACK_ATOMIC + _BUSY_SNAPSHOT _ErrorCode = util.BUSY_SNAPSHOT _CANTOPEN_FULLPATH _ErrorCode = util.CANTOPEN_FULLPATH _CANTOPEN_ISDIR _ErrorCode = util.CANTOPEN_ISDIR _READONLY_CANTINIT _ErrorCode = util.READONLY_CANTINIT diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/file.go b/vendor/github.com/ncruces/go-sqlite3/vfs/file.go index ca8cf84f3a..93a2f7eced 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/file.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/file.go @@ -95,6 +95,9 @@ func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error f, err = osutil.OpenFile(name.String(), oflags, 0666) } if err != nil { + if name == nil { + return nil, flags, _IOERR_GETTEMPPATH + } if errors.Is(err, syscall.EISDIR) { return nil, flags, _CANTOPEN_ISDIR } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/lock.go b/vendor/github.com/ncruces/go-sqlite3/vfs/lock.go index 57bc5f9065..86a988ae87 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/lock.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/lock.go @@ -1,4 +1,4 @@ -//go:build (linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos) && !sqlite3_nosys +//go:build (linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && !sqlite3_nosys package vfs diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/lock_other.go b/vendor/github.com/ncruces/go-sqlite3/vfs/lock_other.go index a4563af484..c395f34a73 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/lock_other.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/lock_other.go @@ -1,4 +1,4 @@ -//go:build !(linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos) || sqlite3_nosys +//go:build !(linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) || sqlite3_nosys package vfs diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go index 48ac5c9c9d..9f3c99dafa 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go @@ -29,5 +29,12 @@ func osReadLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time. } func osWriteLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.Duration) _ErrorCode { - return osLock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK) + rc := osLock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK) + if rc == _BUSY { + // The documentation states the lock is upgraded by releasing the previous lock, + // then acquiring the new lock. + // This is a race, so return BUSY_SNAPSHOT to ensure the transaction is aborted. + return _BUSY_SNAPSHOT + } + return rc } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go index 9826eb274e..8bfe96bb15 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go @@ -1,4 +1,4 @@ -//go:build !sqlite3_flock && !sqlite3_nosys +//go:build !(sqlite3_flock || sqlite3_nosys) package vfs diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go index 8a43f43921..7bb78c0af2 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go @@ -1,4 +1,4 @@ -//go:build !sqlite3_nosys +//go:build !(sqlite3_flock || sqlite3_nosys) package vfs @@ -56,7 +56,7 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d if timeout < time.Since(before) { break } - osSleep(time.Duration(rand.Int63n(int64(time.Millisecond)))) + time.Sleep(time.Duration(rand.Int63n(int64(time.Millisecond)))) } } return osLockErrorCode(err, def) diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_std_sleep.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_std_sleep.go deleted file mode 100644 index c6bc407694..0000000000 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_std_sleep.go +++ /dev/null @@ -1,9 +0,0 @@ -//go:build !windows || sqlite3_nosys - -package vfs - -import "time" - -func osSleep(d time.Duration) { - time.Sleep(d) -} diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_unix_lock.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_unix_lock.go index cdefa21ed7..85a7b0fc0f 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_unix_lock.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_unix_lock.go @@ -1,4 +1,4 @@ -//go:build (linux || darwin || freebsd || openbsd || netbsd || dragonfly || illumos) && !sqlite3_nosys +//go:build (linux || darwin || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && !sqlite3_nosys package vfs @@ -48,7 +48,7 @@ func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode { // In theory, the downgrade to a SHARED cannot fail because another // process is holding an incompatible lock. If it does, this // indicates that the other process is not following the locking - // protocol. If this happens, return _IOERR_RDLOCK. Returning + // protocol. If this happens, return IOERR_RDLOCK. Returning // BUSY would confuse the upper layer. return _IOERR_RDLOCK } @@ -98,6 +98,9 @@ func osLockErrorCode(err error, def _ErrorCode) _ErrorCode { case unix.EPERM: return _PERM } + if errno == unix.EWOULDBLOCK && unix.EWOULDBLOCK != unix.EAGAIN { + return _BUSY + } } return def } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go b/vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go index 5c68754f84..83b952b168 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go @@ -136,7 +136,7 @@ func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def if timeout < time.Since(before) { break } - osSleep(time.Duration(rand.Int63n(int64(time.Millisecond)))) + time.Sleep(time.Duration(rand.Int63n(int64(time.Millisecond)))) } } return osLockErrorCode(err, def) @@ -171,16 +171,3 @@ func osLockErrorCode(err error, def _ErrorCode) _ErrorCode { } return def } - -func osSleep(d time.Duration) { - if d > 0 { - period := max(1, d/(5*time.Millisecond)) - if period < 16 { - windows.TimeBeginPeriod(uint32(period)) - } - time.Sleep(d) - if period < 16 { - windows.TimeEndPeriod(uint32(period)) - } - } -} diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm.go index 2b76dd5dcf..7b0d4b677f 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/shm.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm.go @@ -51,12 +51,7 @@ type vfsShm struct { readOnly bool } -func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (uint32, error) { - // Ensure size is a multiple of the OS page size. - if int(size)&(unix.Getpagesize()-1) != 0 { - return 0, _IOERR_SHMMAP - } - +func (s *vfsShm) shmOpen() _ErrorCode { if s.File == nil { var flag int if s.readOnly { @@ -67,28 +62,40 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext f, err := os.OpenFile(s.path, flag|unix.O_CREAT|unix.O_NOFOLLOW, 0666) if err != nil { - return 0, _CANTOPEN + return _CANTOPEN } s.File = f } // Dead man's switch. if lock, rc := osGetLock(s.File, _SHM_DMS, 1); rc != _OK { - return 0, _IOERR_LOCK + return _IOERR_LOCK } else if lock == unix.F_WRLCK { - return 0, _BUSY + return _BUSY } else if lock == unix.F_UNLCK { if s.readOnly { - return 0, _READONLY_CANTINIT + return _READONLY_CANTINIT } if rc := osWriteLock(s.File, _SHM_DMS, 1, 0); rc != _OK { - return 0, rc + return rc } if err := s.Truncate(0); err != nil { - return 0, _IOERR_SHMOPEN + return _IOERR_SHMOPEN } } if rc := osReadLock(s.File, _SHM_DMS, 1, 0); rc != _OK { + return rc + } + return _OK +} + +func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (uint32, _ErrorCode) { + // Ensure size is a multiple of the OS page size. + if int(size)&(unix.Getpagesize()-1) != 0 { + return 0, _IOERR_SHMMAP + } + + if rc := s.shmOpen(); rc != _OK { return 0, rc } @@ -99,7 +106,7 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext } if n := (int64(id) + 1) * int64(size); n > o { if !extend { - return 0, nil + return 0, _OK } err := osAllocate(s.File, n) if err != nil { @@ -115,13 +122,16 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext } r, err := util.MapRegion(ctx, mod, s.File, int64(id)*int64(size), size, prot) if err != nil { - return 0, err + return 0, _IOERR_SHMMAP } s.regions = append(s.regions, r) - return r.Ptr, nil + if s.readOnly { + return r.Ptr, _READONLY + } + return r.Ptr, _OK } -func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) error { +func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) _ErrorCode { // Argument check. if n <= 0 || offset < 0 || offset+n > _SHM_NLOCK { panic(util.AssertErr()) @@ -165,9 +175,9 @@ func (s *vfsShm) shmUnmap(delete bool) { s.regions = s.regions[:0] // Close the file. - defer s.Close() if delete { - os.Remove(s.Name()) + os.Remove(s.path) } + s.Close() s.File = nil } diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_bsd.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_bsd.go new file mode 100644 index 0000000000..ffeb3e0a00 --- /dev/null +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_bsd.go @@ -0,0 +1,260 @@ +//go:build (freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && (amd64 || arm64 || riscv64) && !(sqlite3_noshm || sqlite3_nosys) + +package vfs + +import ( + "context" + "io" + "os" + "sync" + + "github.com/ncruces/go-sqlite3/internal/util" + "github.com/tetratelabs/wazero/api" + "golang.org/x/sys/unix" +) + +// SupportsSharedMemory is false on platforms that do not support shared memory. +// To use [WAL without shared-memory], you need to set [EXCLUSIVE locking mode]. +// +// [WAL without shared-memory]: https://sqlite.org/wal.html#noshm +// [EXCLUSIVE locking mode]: https://sqlite.org/pragma.html#pragma_locking_mode +const SupportsSharedMemory = true + +const _SHM_NLOCK = 8 + +func (f *vfsFile) SharedMemory() SharedMemory { return f.shm } + +// NewSharedMemory returns a shared-memory WAL-index +// backed by a file with the given path. +// It will return nil if shared-memory is not supported, +// or not appropriate for the given flags. +// Only [OPEN_MAIN_DB] databases may need a WAL-index. +// You must ensure all concurrent accesses to a database +// use shared-memory instances created with the same path. +func NewSharedMemory(path string, flags OpenFlag) SharedMemory { + if flags&OPEN_MAIN_DB == 0 || flags&(OPEN_DELETEONCLOSE|OPEN_MEMORY) != 0 { + return nil + } + return &vfsShm{ + path: path, + readOnly: flags&OPEN_READONLY != 0, + } +} + +type vfsShmFile struct { + *os.File + info os.FileInfo + + // +checklocks:vfsShmFilesMtx + refs int + + // +checklocks:lockMtx + lock [_SHM_NLOCK]int16 + lockMtx sync.Mutex +} + +var ( + // +checklocks:vfsShmFilesMtx + vfsShmFiles []*vfsShmFile + vfsShmFilesMtx sync.Mutex +) + +type vfsShm struct { + *vfsShmFile + path string + lock [_SHM_NLOCK]bool + regions []*util.MappedRegion + readOnly bool +} + +func (s *vfsShm) Close() error { + if s.vfsShmFile == nil { + return nil + } + + // Unlock everything. + s.shmLock(0, _SHM_NLOCK, _SHM_UNLOCK) + + vfsShmFilesMtx.Lock() + defer vfsShmFilesMtx.Unlock() + + // Decrease reference count. + if s.vfsShmFile.refs > 1 { + s.vfsShmFile.refs-- + s.vfsShmFile = nil + return nil + } + for i, g := range vfsShmFiles { + if g == s.vfsShmFile { + vfsShmFiles[i] = nil + break + } + } + + err := s.File.Close() + s.vfsShmFile = nil + return err +} + +func (s *vfsShm) shmOpen() (rc _ErrorCode) { + if s.vfsShmFile != nil { + return _OK + } + + // Always open file read-write, as it will be shared. + f, err := os.OpenFile(s.path, + unix.O_RDWR|unix.O_CREAT|unix.O_NOFOLLOW, 0666) + if err != nil { + return _CANTOPEN + } + // Closes file if it's not nil. + defer func() { f.Close() }() + + fi, err := f.Stat() + if err != nil { + return _IOERR_FSTAT + } + + vfsShmFilesMtx.Lock() + defer vfsShmFilesMtx.Unlock() + + // Find a shared file, increase the reference count. + for _, g := range vfsShmFiles { + if g != nil && os.SameFile(fi, g.info) { + g.refs++ + s.vfsShmFile = g + return _OK + } + } + + // Lock and truncate the file, if not readonly. + // The lock is only released by closing the file. + if s.readOnly { + rc = _READONLY_CANTINIT + } else { + if rc := osLock(f, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK); rc != _OK { + return rc + } + if err := f.Truncate(0); err != nil { + return _IOERR_SHMOPEN + } + } + + // Add the new shared file. + s.vfsShmFile = &vfsShmFile{ + File: f, + info: fi, + refs: 1, + } + f = nil // Don't close the file. + for i, g := range vfsShmFiles { + if g == nil { + vfsShmFiles[i] = s.vfsShmFile + return rc + } + } + vfsShmFiles = append(vfsShmFiles, s.vfsShmFile) + return rc +} + +func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (uint32, _ErrorCode) { + // Ensure size is a multiple of the OS page size. + if int(size)&(unix.Getpagesize()-1) != 0 { + return 0, _IOERR_SHMMAP + } + + if rc := s.shmOpen(); rc != _OK { + return 0, rc + } + + // Check if file is big enough. + o, err := s.Seek(0, io.SeekEnd) + if err != nil { + return 0, _IOERR_SHMSIZE + } + if n := (int64(id) + 1) * int64(size); n > o { + if !extend { + return 0, _OK + } + err := osAllocate(s.File, n) + if err != nil { + return 0, _IOERR_SHMSIZE + } + } + + var prot int + if s.readOnly { + prot = unix.PROT_READ + } else { + prot = unix.PROT_READ | unix.PROT_WRITE + } + r, err := util.MapRegion(ctx, mod, s.File, int64(id)*int64(size), size, prot) + if err != nil { + return 0, _IOERR_SHMMAP + } + s.regions = append(s.regions, r) + if s.readOnly { + return r.Ptr, _READONLY + } + return r.Ptr, _OK +} + +func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) _ErrorCode { + s.lockMtx.Lock() + defer s.lockMtx.Unlock() + + switch { + case flags&_SHM_UNLOCK != 0: + for i := offset; i < offset+n; i++ { + if s.lock[i] { + if s.vfsShmFile.lock[i] <= 0 { + s.vfsShmFile.lock[i] = 0 + } else { + s.vfsShmFile.lock[i]-- + } + } + } + case flags&_SHM_SHARED != 0: + for i := offset; i < offset+n; i++ { + if s.vfsShmFile.lock[i] < 0 { + return _BUSY + } + } + for i := offset; i < offset+n; i++ { + s.vfsShmFile.lock[i]++ + s.lock[i] = true + } + case flags&_SHM_EXCLUSIVE != 0: + for i := offset; i < offset+n; i++ { + if s.vfsShmFile.lock[i] != 0 { + return _BUSY + } + } + for i := offset; i < offset+n; i++ { + s.vfsShmFile.lock[i] = -1 + s.lock[i] = true + } + } + + return _OK +} + +func (s *vfsShm) shmUnmap(delete bool) { + if s.vfsShmFile == nil { + return + } + + // Unmap regions. + for _, r := range s.regions { + r.Unmap() + } + clear(s.regions) + s.regions = s.regions[:0] + + // Close the file. + if delete { + os.Remove(s.path) + } + s.Close() + s.vfsShmFile = nil +} diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_other.go b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_other.go index 21191979ec..7c89975813 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/shm_other.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/shm_other.go @@ -1,4 +1,4 @@ -//go:build !(darwin || linux) || !(amd64 || arm64 || riscv64) || sqlite3_flock || sqlite3_noshm || sqlite3_nosys +//go:build !(darwin || linux || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) || !(amd64 || arm64 || riscv64) || sqlite3_noshm || sqlite3_nosys package vfs diff --git a/vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go b/vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go index 1887e9f221..d624aa78c3 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go +++ b/vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go @@ -83,7 +83,7 @@ func vfsRandomness(ctx context.Context, mod api.Module, pVfs uint32, nByte int32 } func vfsSleep(ctx context.Context, mod api.Module, pVfs uint32, nMicro int32) _ErrorCode { - osSleep(time.Duration(nMicro) * time.Microsecond) + time.Sleep(time.Duration(nMicro) * time.Microsecond) return _OK } @@ -397,18 +397,14 @@ func vfsShmBarrier(ctx context.Context, mod api.Module, pFile uint32) { func vfsShmMap(ctx context.Context, mod api.Module, pFile uint32, iRegion, szRegion int32, bExtend, pp uint32) _ErrorCode { shm := vfsFileGet(ctx, mod, pFile).(FileSharedMemory).SharedMemory() - p, err := shm.shmMap(ctx, mod, iRegion, szRegion, bExtend != 0) - if err != nil { - return vfsErrorCode(err, _IOERR_SHMMAP) - } + p, rc := shm.shmMap(ctx, mod, iRegion, szRegion, bExtend != 0) util.WriteUint32(mod, pp, p) - return _OK + return rc } func vfsShmLock(ctx context.Context, mod api.Module, pFile uint32, offset, n int32, flags _ShmFlag) _ErrorCode { shm := vfsFileGet(ctx, mod, pFile).(FileSharedMemory).SharedMemory() - err := shm.shmLock(offset, n, flags) - return vfsErrorCode(err, _IOERR_SHMLOCK) + return shm.shmLock(offset, n, flags) } func vfsShmUnmap(ctx context.Context, mod api.Module, pFile, bDelete uint32) _ErrorCode { diff --git a/vendor/github.com/ncruces/go-sqlite3/vtab.go b/vendor/github.com/ncruces/go-sqlite3/vtab.go index a330c98ffb..7c19330bb2 100644 --- a/vendor/github.com/ncruces/go-sqlite3/vtab.go +++ b/vendor/github.com/ncruces/go-sqlite3/vtab.go @@ -16,14 +16,15 @@ func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor var flags int const ( - VTAB_CREATOR = 0x01 - VTAB_DESTROYER = 0x02 - VTAB_UPDATER = 0x04 - VTAB_RENAMER = 0x08 - VTAB_OVERLOADER = 0x10 - VTAB_CHECKER = 0x20 - VTAB_TXN = 0x40 - VTAB_SAVEPOINTER = 0x80 + VTAB_CREATOR = 0x001 + VTAB_DESTROYER = 0x002 + VTAB_UPDATER = 0x004 + VTAB_RENAMER = 0x008 + VTAB_OVERLOADER = 0x010 + VTAB_CHECKER = 0x020 + VTAB_TXN = 0x040 + VTAB_SAVEPOINTER = 0x080 + VTAB_SHADOWTABS = 0x100 ) if create != nil { @@ -52,6 +53,9 @@ func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor if implements[VTabSavepointer](vtab) { flags |= VTAB_SAVEPOINTER } + if implements[VTabShadowTabler](vtab) { + flags |= VTAB_SHADOWTABS + } defer db.arena.mark()() namePtr := db.arena.string(name) @@ -174,6 +178,17 @@ type VTabOverloader interface { FindFunction(arg int, name string) (ScalarFunction, IndexConstraintOp) } +// A VTabShadowTabler allows a virtual table to protect the content +// of shadow tables from being corrupted by hostile SQL. +// +// Implementing this interface signals that a virtual table named +// "mumble" reserves all table names starting with "mumble_". +type VTabShadowTabler interface { + VTab + // https://sqlite.org/vtab.html#the_xshadowname_method + ShadowTables() +} + // A VTabChecker allows a virtual table to report errors // to the PRAGMA integrity_check and PRAGMA quick_check commands. // diff --git a/vendor/github.com/tetratelabs/wazero/config.go b/vendor/github.com/tetratelabs/wazero/config.go index 819a76df5e..d3656849cf 100644 --- a/vendor/github.com/tetratelabs/wazero/config.go +++ b/vendor/github.com/tetratelabs/wazero/config.go @@ -148,7 +148,7 @@ type RuntimeConfig interface { // customSections := c.CustomSections() WithCustomSections(bool) RuntimeConfig - // WithCloseOnContextDone ensures the executions of functions to be closed under one of the following circumstances: + // WithCloseOnContextDone ensures the executions of functions to be terminated under one of the following circumstances: // // - context.Context passed to the Call method of api.Function is canceled during execution. (i.e. ctx by context.WithCancel) // - context.Context passed to the Call method of api.Function reaches timeout during execution. (i.e. ctx by context.WithTimeout or context.WithDeadline) @@ -159,6 +159,8 @@ type RuntimeConfig interface { // entire underlying OS thread which runs the api.Function call. See "Why it's safe to execute runtime-generated // machine codes against async Goroutine preemption" section in RATIONALE.md for detail. // + // Upon the termination of the function executions, api.Module is closed. + // // Note that this comes with a bit of extra cost when enabled. The reason is that internally this forces // interpreter and compiler runtimes to insert the periodical checks on the conditions above. For that reason, // this is disabled by default. @@ -217,9 +219,18 @@ const ( // part. wazero automatically performs ahead-of-time compilation as needed when // Runtime.CompileModule is invoked. // -// Warning: This panics at runtime if the runtime.GOOS or runtime.GOARCH does not -// support compiler. Use NewRuntimeConfig to safely detect and fallback to -// NewRuntimeConfigInterpreter if needed. +// # Warning +// +// - This panics at runtime if the runtime.GOOS or runtime.GOARCH does not +// support compiler. Use NewRuntimeConfig to safely detect and fallback to +// NewRuntimeConfigInterpreter if needed. +// +// - If you are using wazero in buildmode=c-archive or c-shared, make sure that you set up the alternate signal stack +// by using, e.g. `sigaltstack` combined with `SA_ONSTACK` flag on `sigaction` on Linux, +// before calling any api.Function. This is because the Go runtime does not set up the alternate signal stack +// for c-archive or c-shared modes, and wazero uses the different stack than the calling Goroutine. +// Hence, the signal handler might get invoked on the wazero's stack, which may cause a stack overflow. +// https://github.com/tetratelabs/wazero/blob/2092c0a879f30d49d7b37f333f4547574b8afe0d/internal/integration_test/fuzz/fuzz/tests/sigstack.rs#L19-L36 func NewRuntimeConfigCompiler() RuntimeConfig { ret := engineLessConfig.clone() ret.engineKind = engineKindCompiler diff --git a/vendor/github.com/tetratelabs/wazero/experimental/checkpoint.go b/vendor/github.com/tetratelabs/wazero/experimental/checkpoint.go index 443c5a294f..c75db615e6 100644 --- a/vendor/github.com/tetratelabs/wazero/experimental/checkpoint.go +++ b/vendor/github.com/tetratelabs/wazero/experimental/checkpoint.go @@ -21,13 +21,6 @@ type Snapshotter interface { Snapshot() Snapshot } -// EnableSnapshotterKey is a context key to indicate that snapshotting should be enabled. -// The context.Context passed to a exported function invocation should have this key set -// to a non-nil value, and host functions will be able to retrieve it using SnapshotterKey. -// -// Deprecated: use WithSnapshotter to enable snapshots. -type EnableSnapshotterKey = expctxkeys.EnableSnapshotterKey - // WithSnapshotter enables snapshots. // Passing the returned context to a exported function invocation enables snapshots, // and allows host functions to retrieve the Snapshotter using GetSnapshotter. @@ -35,12 +28,6 @@ func WithSnapshotter(ctx context.Context) context.Context { return context.WithValue(ctx, expctxkeys.EnableSnapshotterKey{}, struct{}{}) } -// SnapshotterKey is a context key to access a Snapshotter from a host function. -// It is only present if EnableSnapshotter was set in the function invocation context. -// -// Deprecated: use GetSnapshotter to get the snapshotter. -type SnapshotterKey = expctxkeys.SnapshotterKey - // GetSnapshotter gets the Snapshotter from a host function. // It is only present if WithSnapshotter was called with the function invocation context. func GetSnapshotter(ctx context.Context) Snapshotter { diff --git a/vendor/github.com/tetratelabs/wazero/experimental/listener.go b/vendor/github.com/tetratelabs/wazero/experimental/listener.go index b2ba1fe834..55fc6b668e 100644 --- a/vendor/github.com/tetratelabs/wazero/experimental/listener.go +++ b/vendor/github.com/tetratelabs/wazero/experimental/listener.go @@ -24,12 +24,6 @@ type StackIterator interface { ProgramCounter() ProgramCounter } -// FunctionListenerFactoryKey is a context.Context Value key. -// Its associated value should be a FunctionListenerFactory. -// -// Deprecated: use WithFunctionListenerFactory to enable snapshots. -type FunctionListenerFactoryKey = expctxkeys.FunctionListenerFactoryKey - // WithFunctionListenerFactory registers a FunctionListenerFactory // with the context. func WithFunctionListenerFactory(ctx context.Context, factory FunctionListenerFactory) context.Context { diff --git a/vendor/github.com/tetratelabs/wazero/experimental/sys/syscall_errno_windows.go b/vendor/github.com/tetratelabs/wazero/experimental/sys/syscall_errno_windows.go index 761a1f9dc2..5ebc1780f4 100644 --- a/vendor/github.com/tetratelabs/wazero/experimental/sys/syscall_errno_windows.go +++ b/vendor/github.com/tetratelabs/wazero/experimental/sys/syscall_errno_windows.go @@ -23,6 +23,10 @@ const ( // instead of syscall.ENOTDIR _ERROR_DIRECTORY = syscall.Errno(0x10B) + // _ERROR_NOT_A_REPARSE_POINT is a Windows error returned by os.Readlink + // instead of syscall.EINVAL + _ERROR_NOT_A_REPARSE_POINT = syscall.Errno(0x1126) + // _ERROR_INVALID_SOCKET is a Windows error returned by winsock_select // when a given handle is not a socket. _ERROR_INVALID_SOCKET = syscall.Errno(0x2736) @@ -51,7 +55,7 @@ func errorToErrno(err error) Errno { return EBADF case syscall.ERROR_PRIVILEGE_NOT_HELD: return EPERM - case _ERROR_NEGATIVE_SEEK, _ERROR_INVALID_NAME: + case _ERROR_NEGATIVE_SEEK, _ERROR_INVALID_NAME, _ERROR_NOT_A_REPARSE_POINT: return EINVAL } errno, _ := syscallToErrno(err) diff --git a/vendor/github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1/fs.go b/vendor/github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1/fs.go index 384036a275..1ec0d81b37 100644 --- a/vendor/github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1/fs.go +++ b/vendor/github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1/fs.go @@ -1596,6 +1596,10 @@ func pathOpenFn(_ context.Context, mod api.Module, params []uint64) experimental return errno } + if pathLen == 0 { + return experimentalsys.EINVAL + } + fileOpenFlags := openFlags(dirflags, oflags, fdflags, rights) isDir := fileOpenFlags&experimentalsys.O_DIRECTORY != 0 @@ -1704,7 +1708,6 @@ func openFlags(dirflags, oflags, fdflags uint16, rights uint32) (openFlags exper } if oflags&wasip1.O_DIRECTORY != 0 { openFlags |= experimentalsys.O_DIRECTORY - return // Early return for directories as the rest of flags doesn't make sense for it. } else if oflags&wasip1.O_EXCL != 0 { openFlags |= experimentalsys.O_EXCL } @@ -1951,16 +1954,16 @@ func pathSymlinkFn(_ context.Context, mod api.Module, params []uint64) experimen return experimentalsys.EFAULT } - newPathBuf, ok := mem.Read(newPath, newPathLen) - if !ok { - return experimentalsys.EFAULT + _, newPathName, errno := atPath(fsc, mod.Memory(), fd, newPath, newPathLen) + if errno != 0 { + return errno } return dir.FS.Symlink( // Do not join old path since it's only resolved when dereference the link created here. // And the dereference result depends on the opening directory's file descriptor at that point. bufToStr(oldPathBuf), - path.Join(dir.Name, bufToStr(newPathBuf)), + newPathName, ) } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/interpreter/interpreter.go b/vendor/github.com/tetratelabs/wazero/internal/engine/interpreter/interpreter.go index a89ddc4573..18c5f4252d 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/interpreter/interpreter.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/interpreter/interpreter.go @@ -98,6 +98,9 @@ func (e *moduleEngine) SetGlobalValue(idx wasm.Index, lo, hi uint64) { // OwnsGlobals implements the same method as documented on wasm.ModuleEngine. func (e *moduleEngine) OwnsGlobals() bool { return false } +// MemoryGrown implements wasm.ModuleEngine. +func (e *moduleEngine) MemoryGrown() {} + // callEngine holds context per moduleEngine.Call, and shared across all the // function calls originating from the same moduleEngine.Call execution. // diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/executable_context.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/executable_context.go index 81c6a6b62e..8e9571b202 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/executable_context.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/executable_context.go @@ -43,7 +43,7 @@ type ExecutableContextT[Instr any] struct { labelPositionPool wazevoapi.Pool[LabelPosition[Instr]] NextLabel Label // LabelPositions maps a label to the instructions of the region which the label represents. - LabelPositions map[Label]*LabelPosition[Instr] + LabelPositions []*LabelPosition[Instr] OrderedBlockLabels []*LabelPosition[Instr] // PerBlockHead and PerBlockEnd are the head and tail of the instruction list per currently-compiled ssa.BasicBlock. @@ -67,7 +67,6 @@ func NewExecutableContextT[Instr any]( setNext: setNext, setPrev: setPrev, labelPositionPool: wazevoapi.NewPool[LabelPosition[Instr]](resetLabelPosition[Instr]), - LabelPositions: make(map[Label]*LabelPosition[Instr]), NextLabel: LabelInvalid, } } @@ -97,11 +96,7 @@ func (e *ExecutableContextT[Instr]) StartBlock(blk ssa.BasicBlock) { end := e.allocateNop0() e.PerBlockHead, e.PerBlockEnd = end, end - labelPos, ok := e.LabelPositions[l] - if !ok { - labelPos = e.AllocateLabelPosition(l) - e.LabelPositions[l] = labelPos - } + labelPos := e.GetOrAllocateLabelPosition(l) e.OrderedBlockLabels = append(e.OrderedBlockLabels, labelPos) labelPos.Begin, labelPos.End = end, end labelPos.SB = blk @@ -146,8 +141,8 @@ func (e *ExecutableContextT[T]) FlushPendingInstructions() { func (e *ExecutableContextT[T]) Reset() { e.labelPositionPool.Reset() e.InstructionPool.Reset() - for l := Label(0); l <= e.NextLabel; l++ { - delete(e.LabelPositions, l) + for i := range e.LabelPositions { + e.LabelPositions[i] = nil } e.PendingInstructions = e.PendingInstructions[:0] e.OrderedBlockLabels = e.OrderedBlockLabels[:0] @@ -163,10 +158,17 @@ func (e *ExecutableContextT[T]) AllocateLabel() Label { return e.NextLabel } -func (e *ExecutableContextT[T]) AllocateLabelPosition(la Label) *LabelPosition[T] { - l := e.labelPositionPool.Allocate() - l.L = la - return l +func (e *ExecutableContextT[T]) GetOrAllocateLabelPosition(l Label) *LabelPosition[T] { + if len(e.LabelPositions) <= int(l) { + e.LabelPositions = append(e.LabelPositions, make([]*LabelPosition[T], int(l)+1-len(e.LabelPositions))...) + } + ret := e.LabelPositions[l] + if ret == nil { + ret = e.labelPositionPool.Allocate() + ret.L = l + e.LabelPositions[l] = ret + } + return ret } func (e *ExecutableContextT[T]) GetOrAllocateSSABlockLabel(blk ssa.BasicBlock) Label { diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/amd64/machine.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/amd64/machine.go index 310ad2203a..61ae6f4061 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/amd64/machine.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/amd64/machine.go @@ -1906,8 +1906,10 @@ func (m *machine) InsertMove(dst, src regalloc.VReg, typ ssa.Type) { func (m *machine) Format() string { ectx := m.ectx begins := map[*instruction]backend.Label{} - for l, pos := range ectx.LabelPositions { - begins[pos.Begin] = l + for _, pos := range ectx.LabelPositions { + if pos != nil { + begins[pos.Begin] = pos.L + } } irBlocks := map[backend.Label]ssa.BasicBlockID{} @@ -1950,7 +1952,10 @@ func (m *machine) encodeWithoutSSA(root *instruction) { offset := int64(len(*bufPtr)) if cur.kind == nop0 { l := cur.nop0Label() - if pos, ok := ectx.LabelPositions[l]; ok { + if int(l) >= len(ectx.LabelPositions) { + continue + } + if pos := ectx.LabelPositions[l]; pos != nil { pos.BinaryOffset = offset } } @@ -2005,7 +2010,7 @@ func (m *machine) Encode(ctx context.Context) (err error) { switch cur.kind { case nop0: l := cur.nop0Label() - if pos, ok := ectx.LabelPositions[l]; ok { + if pos := ectx.LabelPositions[l]; pos != nil { pos.BinaryOffset = offset } case sourceOffsetInfo: @@ -2165,8 +2170,7 @@ func (m *machine) allocateBrTarget() (nop *instruction, l backend.Label) { //nol func (m *machine) allocateLabel() *labelPosition { ectx := m.ectx l := ectx.AllocateLabel() - pos := ectx.AllocateLabelPosition(l) - ectx.LabelPositions[l] = pos + pos := ectx.GetOrAllocateLabelPosition(l) return pos } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi.go index 6615471c6a..4eaa13ce1c 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi.go @@ -101,13 +101,14 @@ func (m *machine) LowerParams(args []ssa.Value) { bits := arg.Type.Bits() // At this point of compilation, we don't yet know how much space exist below the return address. // So we instruct the address mode to add the `argStackOffset` to the offset at the later phase of compilation. - amode := addressMode{imm: arg.Offset, rn: spVReg, kind: addressModeKindArgStackSpace} + amode := m.amodePool.Allocate() + *amode = addressMode{imm: arg.Offset, rn: spVReg, kind: addressModeKindArgStackSpace} load := m.allocateInstr() switch arg.Type { case ssa.TypeI32, ssa.TypeI64: - load.asULoad(operandNR(reg), amode, bits) + load.asULoad(reg, amode, bits) case ssa.TypeF32, ssa.TypeF64, ssa.TypeV128: - load.asFpuLoad(operandNR(reg), amode, bits) + load.asFpuLoad(reg, amode, bits) default: panic("BUG") } @@ -169,7 +170,8 @@ func (m *machine) LowerReturns(rets []ssa.Value) { // At this point of compilation, we don't yet know how much space exist below the return address. // So we instruct the address mode to add the `retStackOffset` to the offset at the later phase of compilation. - amode := addressMode{imm: r.Offset, rn: spVReg, kind: addressModeKindResultStackSpace} + amode := m.amodePool.Allocate() + *amode = addressMode{imm: r.Offset, rn: spVReg, kind: addressModeKindResultStackSpace} store := m.allocateInstr() store.asStore(operandNR(reg), amode, bits) m.insert(store) @@ -215,9 +217,9 @@ func (m *machine) callerGenFunctionReturnVReg(a *backend.FunctionABI, retIndex i ldr := m.allocateInstr() switch r.Type { case ssa.TypeI32, ssa.TypeI64: - ldr.asULoad(operandNR(reg), amode, r.Type.Bits()) + ldr.asULoad(reg, amode, r.Type.Bits()) case ssa.TypeF32, ssa.TypeF64, ssa.TypeV128: - ldr.asFpuLoad(operandNR(reg), amode, r.Type.Bits()) + ldr.asFpuLoad(reg, amode, r.Type.Bits()) default: panic("BUG") } @@ -225,7 +227,7 @@ func (m *machine) callerGenFunctionReturnVReg(a *backend.FunctionABI, retIndex i } } -func (m *machine) resolveAddressModeForOffsetAndInsert(cur *instruction, offset int64, dstBits byte, rn regalloc.VReg, allowTmpRegUse bool) (*instruction, addressMode) { +func (m *machine) resolveAddressModeForOffsetAndInsert(cur *instruction, offset int64, dstBits byte, rn regalloc.VReg, allowTmpRegUse bool) (*instruction, *addressMode) { exct := m.executableContext exct.PendingInstructions = exct.PendingInstructions[:0] mode := m.resolveAddressModeForOffset(offset, dstBits, rn, allowTmpRegUse) @@ -235,15 +237,15 @@ func (m *machine) resolveAddressModeForOffsetAndInsert(cur *instruction, offset return cur, mode } -func (m *machine) resolveAddressModeForOffset(offset int64, dstBits byte, rn regalloc.VReg, allowTmpRegUse bool) addressMode { +func (m *machine) resolveAddressModeForOffset(offset int64, dstBits byte, rn regalloc.VReg, allowTmpRegUse bool) *addressMode { if rn.RegType() != regalloc.RegTypeInt { panic("BUG: rn should be a pointer: " + formatVRegSized(rn, 64)) } - var amode addressMode + amode := m.amodePool.Allocate() if offsetFitsInAddressModeKindRegUnsignedImm12(dstBits, offset) { - amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: rn, imm: offset} + *amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: rn, imm: offset} } else if offsetFitsInAddressModeKindRegSignedImm9(offset) { - amode = addressMode{kind: addressModeKindRegSignedImm9, rn: rn, imm: offset} + *amode = addressMode{kind: addressModeKindRegSignedImm9, rn: rn, imm: offset} } else { var indexReg regalloc.VReg if allowTmpRegUse { @@ -253,7 +255,7 @@ func (m *machine) resolveAddressModeForOffset(offset int64, dstBits byte, rn reg indexReg = m.compiler.AllocateVReg(ssa.TypeI64) m.lowerConstantI64(indexReg, offset) } - amode = addressMode{kind: addressModeKindRegReg, rn: rn, rm: indexReg, extOp: extendOpUXTX /* indicates index rm is 64-bit */} + *amode = addressMode{kind: addressModeKindRegReg, rn: rn, rm: indexReg, extOp: extendOpUXTX /* indicates index rm is 64-bit */} } return amode } @@ -315,7 +317,7 @@ func (m *machine) insertAddOrSubStackPointer(rd regalloc.VReg, diff int64, add b } else { ao = aluOpSub } - alu.asALU(ao, operandNR(rd), operandNR(spVReg), imm12Operand, true) + alu.asALU(ao, rd, operandNR(spVReg), imm12Operand, true) m.insert(alu) } else { m.lowerConstantI64(tmpRegVReg, diff) @@ -326,7 +328,7 @@ func (m *machine) insertAddOrSubStackPointer(rd regalloc.VReg, diff int64, add b } else { ao = aluOpSub } - alu.asALU(ao, operandNR(rd), operandNR(spVReg), operandNR(tmpRegVReg), true) + alu.asALU(ao, rd, operandNR(spVReg), operandNR(tmpRegVReg), true) m.insert(alu) } } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_entry_preamble.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_entry_preamble.go index 7a9cceb332..f8b5d97ac7 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_entry_preamble.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_entry_preamble.go @@ -59,25 +59,26 @@ func (m *machine) goEntryPreamblePassArg(cur *instruction, paramSlicePtr regallo } else { postIndexImm = 8 } - loadMode := addressMode{kind: addressModeKindPostIndex, rn: paramSlicePtr, imm: postIndexImm} + loadMode := m.amodePool.Allocate() + *loadMode = addressMode{kind: addressModeKindPostIndex, rn: paramSlicePtr, imm: postIndexImm} instr := m.allocateInstr() switch typ { case ssa.TypeI32: - instr.asULoad(loadTargetReg, loadMode, 32) + instr.asULoad(loadTargetReg.reg(), loadMode, 32) case ssa.TypeI64: - instr.asULoad(loadTargetReg, loadMode, 64) + instr.asULoad(loadTargetReg.reg(), loadMode, 64) case ssa.TypeF32: - instr.asFpuLoad(loadTargetReg, loadMode, 32) + instr.asFpuLoad(loadTargetReg.reg(), loadMode, 32) case ssa.TypeF64: - instr.asFpuLoad(loadTargetReg, loadMode, 64) + instr.asFpuLoad(loadTargetReg.reg(), loadMode, 64) case ssa.TypeV128: - instr.asFpuLoad(loadTargetReg, loadMode, 128) + instr.asFpuLoad(loadTargetReg.reg(), loadMode, 128) } cur = linkInstr(cur, instr) if isStackArg { - var storeMode addressMode + var storeMode *addressMode cur, storeMode = m.resolveAddressModeForOffsetAndInsert(cur, argStartOffsetFromSP+arg.Offset, bits, spVReg, true) toStack := m.allocateInstr() toStack.asStore(loadTargetReg, storeMode, bits) @@ -113,21 +114,22 @@ func (m *machine) goEntryPreamblePassResult(cur *instruction, resultSlicePtr reg } if isStackArg { - var loadMode addressMode + var loadMode *addressMode cur, loadMode = m.resolveAddressModeForOffsetAndInsert(cur, resultStartOffsetFromSP+result.Offset, bits, spVReg, true) toReg := m.allocateInstr() switch typ { case ssa.TypeI32, ssa.TypeI64: - toReg.asULoad(storeTargetReg, loadMode, bits) + toReg.asULoad(storeTargetReg.reg(), loadMode, bits) case ssa.TypeF32, ssa.TypeF64, ssa.TypeV128: - toReg.asFpuLoad(storeTargetReg, loadMode, bits) + toReg.asFpuLoad(storeTargetReg.reg(), loadMode, bits) default: panic("TODO?") } cur = linkInstr(cur, toReg) } - mode := addressMode{kind: addressModeKindPostIndex, rn: resultSlicePtr, imm: postIndexImm} + mode := m.amodePool.Allocate() + *mode = addressMode{kind: addressModeKindPostIndex, rn: resultSlicePtr, imm: postIndexImm} instr := m.allocateInstr() instr.asStore(storeTargetReg, mode, bits) cur = linkInstr(cur, instr) @@ -214,11 +216,12 @@ func (m *machine) move64(dst, src regalloc.VReg, prev *instruction) *instruction func (m *machine) loadOrStoreAtExecutionContext(d regalloc.VReg, offset wazevoapi.Offset, store bool, prev *instruction) *instruction { instr := m.allocateInstr() - mode := addressMode{kind: addressModeKindRegUnsignedImm12, rn: savedExecutionContextPtr, imm: offset.I64()} + mode := m.amodePool.Allocate() + *mode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: savedExecutionContextPtr, imm: offset.I64()} if store { instr.asStore(operandNR(d), mode, 64) } else { - instr.asULoad(operandNR(d), mode, 64) + instr.asULoad(d, mode, 64) } return linkInstr(prev, instr) } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_go_call.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_go_call.go index 466b1f9609..99e6bb482d 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_go_call.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/abi_go_call.go @@ -87,7 +87,8 @@ func (m *machine) CompileGoFunctionTrampoline(exitCode wazevoapi.ExitCode, sig * // Module context is always the second argument. moduleCtrPtr := x1VReg store := m.allocateInstr() - amode := addressMode{kind: addressModeKindRegUnsignedImm12, rn: execCtrPtr, imm: offset} + amode := m.amodePool.Allocate() + *amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: execCtrPtr, imm: offset} store.asStore(operandNR(moduleCtrPtr), amode, 64) cur = linkInstr(cur, store) } @@ -120,11 +121,9 @@ func (m *machine) CompileGoFunctionTrampoline(exitCode wazevoapi.ExitCode, sig * } else { sizeInBits = 64 } - store.asStore(operandNR(v), - addressMode{ - kind: addressModeKindPostIndex, - rn: arg0ret0AddrReg, imm: int64(sizeInBits / 8), - }, sizeInBits) + amode := m.amodePool.Allocate() + *amode = addressMode{kind: addressModeKindPostIndex, rn: arg0ret0AddrReg, imm: int64(sizeInBits / 8)} + store.asStore(operandNR(v), amode, sizeInBits) cur = linkInstr(cur, store) } @@ -139,7 +138,7 @@ func (m *machine) CompileGoFunctionTrampoline(exitCode wazevoapi.ExitCode, sig * frameSizeReg = xzrVReg sliceSizeReg = xzrVReg } - _amode := addressModePreOrPostIndex(spVReg, -16, true) + _amode := addressModePreOrPostIndex(m, spVReg, -16, true) storeP := m.allocateInstr() storeP.asStorePair64(frameSizeReg, sliceSizeReg, _amode) cur = linkInstr(cur, storeP) @@ -165,8 +164,8 @@ func (m *machine) CompileGoFunctionTrampoline(exitCode wazevoapi.ExitCode, sig * cur = m.addsAddOrSubStackPointer(cur, spVReg, frameInfoSize+goCallStackSize, true) ldr := m.allocateInstr() // And load the return address. - ldr.asULoad(operandNR(lrVReg), - addressModePreOrPostIndex(spVReg, 16 /* stack pointer must be 16-byte aligned. */, false /* increment after loads */), 64) + amode := addressModePreOrPostIndex(m, spVReg, 16 /* stack pointer must be 16-byte aligned. */, false /* increment after loads */) + ldr.asULoad(lrVReg, amode, 64) cur = linkInstr(cur, ldr) originalRet0Reg := x17VReg // Caller save, so we can use it for whatever we want. @@ -183,23 +182,24 @@ func (m *machine) CompileGoFunctionTrampoline(exitCode wazevoapi.ExitCode, sig * r := &abi.Rets[i] if r.Kind == backend.ABIArgKindReg { loadIntoReg := m.allocateInstr() - mode := addressMode{kind: addressModeKindPostIndex, rn: arg0ret0AddrReg} + mode := m.amodePool.Allocate() + *mode = addressMode{kind: addressModeKindPostIndex, rn: arg0ret0AddrReg} switch r.Type { case ssa.TypeI32: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - loadIntoReg.asULoad(operandNR(r.Reg), mode, 32) + loadIntoReg.asULoad(r.Reg, mode, 32) case ssa.TypeI64: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - loadIntoReg.asULoad(operandNR(r.Reg), mode, 64) + loadIntoReg.asULoad(r.Reg, mode, 64) case ssa.TypeF32: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - loadIntoReg.asFpuLoad(operandNR(r.Reg), mode, 32) + loadIntoReg.asFpuLoad(r.Reg, mode, 32) case ssa.TypeF64: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - loadIntoReg.asFpuLoad(operandNR(r.Reg), mode, 64) + loadIntoReg.asFpuLoad(r.Reg, mode, 64) case ssa.TypeV128: mode.imm = 16 - loadIntoReg.asFpuLoad(operandNR(r.Reg), mode, 128) + loadIntoReg.asFpuLoad(r.Reg, mode, 128) default: panic("TODO") } @@ -208,28 +208,29 @@ func (m *machine) CompileGoFunctionTrampoline(exitCode wazevoapi.ExitCode, sig * // First we need to load the value to a temporary just like ^^. intTmp, floatTmp := x11VReg, v11VReg loadIntoTmpReg := m.allocateInstr() - mode := addressMode{kind: addressModeKindPostIndex, rn: arg0ret0AddrReg} + mode := m.amodePool.Allocate() + *mode = addressMode{kind: addressModeKindPostIndex, rn: arg0ret0AddrReg} var resultReg regalloc.VReg switch r.Type { case ssa.TypeI32: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - loadIntoTmpReg.asULoad(operandNR(intTmp), mode, 32) + loadIntoTmpReg.asULoad(intTmp, mode, 32) resultReg = intTmp case ssa.TypeI64: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - loadIntoTmpReg.asULoad(operandNR(intTmp), mode, 64) + loadIntoTmpReg.asULoad(intTmp, mode, 64) resultReg = intTmp case ssa.TypeF32: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - loadIntoTmpReg.asFpuLoad(operandNR(floatTmp), mode, 32) + loadIntoTmpReg.asFpuLoad(floatTmp, mode, 32) resultReg = floatTmp case ssa.TypeF64: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - loadIntoTmpReg.asFpuLoad(operandNR(floatTmp), mode, 64) + loadIntoTmpReg.asFpuLoad(floatTmp, mode, 64) resultReg = floatTmp case ssa.TypeV128: mode.imm = 16 - loadIntoTmpReg.asFpuLoad(operandNR(floatTmp), mode, 128) + loadIntoTmpReg.asFpuLoad(floatTmp, mode, 128) resultReg = floatTmp default: panic("TODO") @@ -258,12 +259,13 @@ func (m *machine) saveRegistersInExecutionContext(cur *instruction, regs []regal case regalloc.RegTypeFloat: sizeInBits = 128 } - store.asStore(operandNR(v), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - // Execution context is always the first argument. - rn: x0VReg, imm: offset, - }, sizeInBits) + mode := m.amodePool.Allocate() + *mode = addressMode{ + kind: addressModeKindRegUnsignedImm12, + // Execution context is always the first argument. + rn: x0VReg, imm: offset, + } + store.asStore(operandNR(v), mode, sizeInBits) store.prev = cur cur.next = store cur = store @@ -276,7 +278,7 @@ func (m *machine) restoreRegistersInExecutionContext(cur *instruction, regs []re offset := wazevoapi.ExecutionContextOffsetSavedRegistersBegin.I64() for _, v := range regs { load := m.allocateInstr() - var as func(dst operand, amode addressMode, sizeInBits byte) + var as func(dst regalloc.VReg, amode *addressMode, sizeInBits byte) var sizeInBits byte switch v.RegType() { case regalloc.RegTypeInt: @@ -286,12 +288,13 @@ func (m *machine) restoreRegistersInExecutionContext(cur *instruction, regs []re as = load.asFpuLoad sizeInBits = 128 } - as(operandNR(v), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - // Execution context is always the first argument. - rn: x0VReg, imm: offset, - }, sizeInBits) + mode := m.amodePool.Allocate() + *mode = addressMode{ + kind: addressModeKindRegUnsignedImm12, + // Execution context is always the first argument. + rn: x0VReg, imm: offset, + } + as(v, mode, sizeInBits) cur = linkInstr(cur, load) offset += 16 // Imm12 must be aligned 16 for vector regs, so we unconditionally load regs at the offset of multiple of 16. } @@ -324,11 +327,9 @@ func (m *machine) setExitCode(cur *instruction, execCtr regalloc.VReg, exitCode // Set the exit status on the execution context. setExistStatus := m.allocateInstr() - setExistStatus.asStore(operandNR(constReg), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - rn: execCtr, imm: wazevoapi.ExecutionContextOffsetExitCodeOffset.I64(), - }, 32) + mode := m.amodePool.Allocate() + *mode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: execCtr, imm: wazevoapi.ExecutionContextOffsetExitCodeOffset.I64()} + setExistStatus.asStore(operandNR(constReg), mode, 32) cur = linkInstr(cur, setExistStatus) return cur } @@ -340,12 +341,13 @@ func (m *machine) storeReturnAddressAndExit(cur *instruction) *instruction { cur = linkInstr(cur, adr) storeReturnAddr := m.allocateInstr() - storeReturnAddr.asStore(operandNR(tmpRegVReg), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - // Execution context is always the first argument. - rn: x0VReg, imm: wazevoapi.ExecutionContextOffsetGoCallReturnAddress.I64(), - }, 64) + mode := m.amodePool.Allocate() + *mode = addressMode{ + kind: addressModeKindRegUnsignedImm12, + // Execution context is always the first argument. + rn: x0VReg, imm: wazevoapi.ExecutionContextOffsetGoCallReturnAddress.I64(), + } + storeReturnAddr.asStore(operandNR(tmpRegVReg), mode, 64) cur = linkInstr(cur, storeReturnAddr) // Exit the execution. @@ -364,11 +366,12 @@ func (m *machine) saveCurrentStackPointer(cur *instruction, execCtr regalloc.VRe cur = linkInstr(cur, movSp) strSp := m.allocateInstr() - strSp.asStore(operandNR(tmpRegVReg), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - rn: execCtr, imm: wazevoapi.ExecutionContextOffsetStackPointerBeforeGoCall.I64(), - }, 64) + mode := m.amodePool.Allocate() + *mode = addressMode{ + kind: addressModeKindRegUnsignedImm12, + rn: execCtr, imm: wazevoapi.ExecutionContextOffsetStackPointerBeforeGoCall.I64(), + } + strSp.asStore(operandNR(tmpRegVReg), mode, 64) cur = linkInstr(cur, strSp) return cur } @@ -376,27 +379,28 @@ func (m *machine) saveCurrentStackPointer(cur *instruction, execCtr regalloc.VRe func (m *machine) goFunctionCallLoadStackArg(cur *instruction, originalArg0Reg regalloc.VReg, arg *backend.ABIArg, intVReg, floatVReg regalloc.VReg) (*instruction, regalloc.VReg) { load := m.allocateInstr() var result regalloc.VReg - mode := addressMode{kind: addressModeKindPostIndex, rn: originalArg0Reg} + mode := m.amodePool.Allocate() + *mode = addressMode{kind: addressModeKindPostIndex, rn: originalArg0Reg} switch arg.Type { case ssa.TypeI32: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - load.asULoad(operandNR(intVReg), mode, 32) + load.asULoad(intVReg, mode, 32) result = intVReg case ssa.TypeI64: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - load.asULoad(operandNR(intVReg), mode, 64) + load.asULoad(intVReg, mode, 64) result = intVReg case ssa.TypeF32: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - load.asFpuLoad(operandNR(floatVReg), mode, 32) + load.asFpuLoad(floatVReg, mode, 32) result = floatVReg case ssa.TypeF64: mode.imm = 8 // We use uint64 for all basic types, except SIMD v128. - load.asFpuLoad(operandNR(floatVReg), mode, 64) + load.asFpuLoad(floatVReg, mode, 64) result = floatVReg case ssa.TypeV128: mode.imm = 16 - load.asFpuLoad(operandNR(floatVReg), mode, 128) + load.asFpuLoad(floatVReg, mode, 128) result = floatVReg default: panic("TODO") @@ -408,7 +412,8 @@ func (m *machine) goFunctionCallLoadStackArg(cur *instruction, originalArg0Reg r func (m *machine) goFunctionCallStoreStackResult(cur *instruction, originalRet0Reg regalloc.VReg, result *backend.ABIArg, resultVReg regalloc.VReg) *instruction { store := m.allocateInstr() - mode := addressMode{kind: addressModeKindPostIndex, rn: originalRet0Reg} + mode := m.amodePool.Allocate() + *mode = addressMode{kind: addressModeKindPostIndex, rn: originalRet0Reg} var sizeInBits byte switch result.Type { case ssa.TypeI32, ssa.TypeF32: diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/instr.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/instr.go index 8aabc5997b..7121cb5382 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/instr.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/instr.go @@ -3,10 +3,12 @@ package arm64 import ( "fmt" "math" + "unsafe" "github.com/tetratelabs/wazero/internal/engine/wazevo/backend" "github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc" "github.com/tetratelabs/wazero/internal/engine/wazevo/ssa" + "github.com/tetratelabs/wazero/internal/engine/wazevo/wazevoapi" ) type ( @@ -22,9 +24,9 @@ type ( // TODO: optimize the layout later once the impl settles. instruction struct { prev, next *instruction - u1, u2, u3 uint64 - rd, rm, rn, ra operand - amode addressMode + u1, u2 uint64 + rd regalloc.VReg + rm, rn operand kind instructionKind addedBeforeRegAlloc bool } @@ -174,7 +176,7 @@ func (i *instruction) Defs(regs *[]regalloc.VReg) []regalloc.VReg { switch defKinds[i.kind] { case defKindNone: case defKindRD: - *regs = append(*regs, i.rd.nr()) + *regs = append(*regs, i.rd) case defKindCall: _, _, retIntRealRegs, retFloatRealRegs, _ := backend.ABIInfoFromUint64(i.u2) for i := byte(0); i < retIntRealRegs; i++ { @@ -194,7 +196,7 @@ func (i *instruction) AssignDef(reg regalloc.VReg) { switch defKinds[i.kind] { case defKindNone: case defKindRD: - i.rd = i.rd.assignReg(reg) + i.rd = reg case defKindCall: panic("BUG: call instructions shouldn't be assigned") default: @@ -329,7 +331,7 @@ func (i *instruction) Uses(regs *[]regalloc.VReg) []regalloc.VReg { if rm := i.rm.reg(); rm.Valid() { *regs = append(*regs, rm) } - if ra := i.ra.reg(); ra.Valid() { + if ra := regalloc.VReg(i.u2); ra.Valid() { *regs = append(*regs, ra) } case useKindRNRN1RM: @@ -341,18 +343,20 @@ func (i *instruction) Uses(regs *[]regalloc.VReg) []regalloc.VReg { *regs = append(*regs, rm) } case useKindAMode: - if amodeRN := i.amode.rn; amodeRN.Valid() { + amode := i.getAmode() + if amodeRN := amode.rn; amodeRN.Valid() { *regs = append(*regs, amodeRN) } - if amodeRM := i.amode.rm; amodeRM.Valid() { + if amodeRM := amode.rm; amodeRM.Valid() { *regs = append(*regs, amodeRM) } case useKindRNAMode: *regs = append(*regs, i.rn.reg()) - if amodeRN := i.amode.rn; amodeRN.Valid() { + amode := i.getAmode() + if amodeRN := amode.rn; amodeRN.Valid() { *regs = append(*regs, amodeRN) } - if amodeRM := i.amode.rm; amodeRM.Valid() { + if amodeRM := amode.rm; amodeRM.Valid() { *regs = append(*regs, amodeRM) } case useKindCond: @@ -374,7 +378,7 @@ func (i *instruction) Uses(regs *[]regalloc.VReg) []regalloc.VReg { case useKindRDRewrite: *regs = append(*regs, i.rn.reg()) *regs = append(*regs, i.rm.reg()) - *regs = append(*regs, i.rd.reg()) + *regs = append(*regs, i.rd) default: panic(fmt.Sprintf("useKind for %v not defined", i)) } @@ -408,8 +412,8 @@ func (i *instruction) AssignUse(index int, reg regalloc.VReg) { i.rm = i.rm.assignReg(reg) } } else { - if rd := i.rd.reg(); rd.Valid() { - i.rd = i.rd.assignReg(reg) + if rd := i.rd; rd.Valid() { + i.rd = reg } } case useKindRNRN1RM: @@ -435,32 +439,36 @@ func (i *instruction) AssignUse(index int, reg regalloc.VReg) { i.rm = i.rm.assignReg(reg) } } else { - if ra := i.ra.reg(); ra.Valid() { - i.ra = i.ra.assignReg(reg) + if ra := regalloc.VReg(i.u2); ra.Valid() { + i.u2 = uint64(reg) } } case useKindAMode: if index == 0 { - if amodeRN := i.amode.rn; amodeRN.Valid() { - i.amode.rn = reg + amode := i.getAmode() + if amodeRN := amode.rn; amodeRN.Valid() { + amode.rn = reg } } else { - if amodeRM := i.amode.rm; amodeRM.Valid() { - i.amode.rm = reg + amode := i.getAmode() + if amodeRM := amode.rm; amodeRM.Valid() { + amode.rm = reg } } case useKindRNAMode: if index == 0 { i.rn = i.rn.assignReg(reg) } else if index == 1 { - if amodeRN := i.amode.rn; amodeRN.Valid() { - i.amode.rn = reg + amode := i.getAmode() + if amodeRN := amode.rn; amodeRN.Valid() { + amode.rn = reg } else { panic("BUG") } } else { - if amodeRM := i.amode.rm; amodeRM.Valid() { - i.amode.rm = reg + amode := i.getAmode() + if amodeRM := amode.rm; amodeRM.Valid() { + amode.rm = reg } else { panic("BUG") } @@ -503,35 +511,35 @@ func (i *instruction) callFuncRef() ssa.FuncRef { } // shift must be divided by 16 and must be in range 0-3 (if dst64bit is true) or 0-1 (if dst64bit is false) -func (i *instruction) asMOVZ(dst regalloc.VReg, imm uint64, shift uint64, dst64bit bool) { +func (i *instruction) asMOVZ(dst regalloc.VReg, imm uint64, shift uint32, dst64bit bool) { i.kind = movZ - i.rd = operandNR(dst) + i.rd = dst i.u1 = imm - i.u2 = shift + i.u2 = uint64(shift) if dst64bit { - i.u3 = 1 + i.u2 |= 1 << 32 } } // shift must be divided by 16 and must be in range 0-3 (if dst64bit is true) or 0-1 (if dst64bit is false) -func (i *instruction) asMOVK(dst regalloc.VReg, imm uint64, shift uint64, dst64bit bool) { +func (i *instruction) asMOVK(dst regalloc.VReg, imm uint64, shift uint32, dst64bit bool) { i.kind = movK - i.rd = operandNR(dst) + i.rd = dst i.u1 = imm - i.u2 = shift + i.u2 = uint64(shift) if dst64bit { - i.u3 = 1 + i.u2 |= 1 << 32 } } // shift must be divided by 16 and must be in range 0-3 (if dst64bit is true) or 0-1 (if dst64bit is false) -func (i *instruction) asMOVN(dst regalloc.VReg, imm uint64, shift uint64, dst64bit bool) { +func (i *instruction) asMOVN(dst regalloc.VReg, imm uint64, shift uint32, dst64bit bool) { i.kind = movN - i.rd = operandNR(dst) + i.rd = dst i.u1 = imm - i.u2 = shift + i.u2 = uint64(shift) if dst64bit { - i.u3 = 1 + i.u2 |= 1 << 32 } } @@ -553,21 +561,21 @@ func (i *instruction) asRet() { i.kind = ret } -func (i *instruction) asStorePair64(src1, src2 regalloc.VReg, amode addressMode) { +func (i *instruction) asStorePair64(src1, src2 regalloc.VReg, amode *addressMode) { i.kind = storeP64 i.rn = operandNR(src1) i.rm = operandNR(src2) - i.amode = amode + i.setAmode(amode) } -func (i *instruction) asLoadPair64(src1, src2 regalloc.VReg, amode addressMode) { +func (i *instruction) asLoadPair64(src1, src2 regalloc.VReg, amode *addressMode) { i.kind = loadP64 i.rn = operandNR(src1) i.rm = operandNR(src2) - i.amode = amode + i.setAmode(amode) } -func (i *instruction) asStore(src operand, amode addressMode, sizeInBits byte) { +func (i *instruction) asStore(src operand, amode *addressMode, sizeInBits byte) { switch sizeInBits { case 8: i.kind = store8 @@ -589,10 +597,10 @@ func (i *instruction) asStore(src operand, amode addressMode, sizeInBits byte) { i.kind = fpuStore128 } i.rn = src - i.amode = amode + i.setAmode(amode) } -func (i *instruction) asSLoad(dst operand, amode addressMode, sizeInBits byte) { +func (i *instruction) asSLoad(dst regalloc.VReg, amode *addressMode, sizeInBits byte) { switch sizeInBits { case 8: i.kind = sLoad8 @@ -604,10 +612,10 @@ func (i *instruction) asSLoad(dst operand, amode addressMode, sizeInBits byte) { panic("BUG") } i.rd = dst - i.amode = amode + i.setAmode(amode) } -func (i *instruction) asULoad(dst operand, amode addressMode, sizeInBits byte) { +func (i *instruction) asULoad(dst regalloc.VReg, amode *addressMode, sizeInBits byte) { switch sizeInBits { case 8: i.kind = uLoad8 @@ -619,10 +627,10 @@ func (i *instruction) asULoad(dst operand, amode addressMode, sizeInBits byte) { i.kind = uLoad64 } i.rd = dst - i.amode = amode + i.setAmode(amode) } -func (i *instruction) asFpuLoad(dst operand, amode addressMode, sizeInBits byte) { +func (i *instruction) asFpuLoad(dst regalloc.VReg, amode *addressMode, sizeInBits byte) { switch sizeInBits { case 32: i.kind = fpuLoad32 @@ -632,10 +640,18 @@ func (i *instruction) asFpuLoad(dst operand, amode addressMode, sizeInBits byte) i.kind = fpuLoad128 } i.rd = dst - i.amode = amode + i.setAmode(amode) } -func (i *instruction) asVecLoad1R(rd, rn operand, arr vecArrangement) { +func (i *instruction) getAmode() *addressMode { + return wazevoapi.PtrFromUintptr[addressMode](uintptr(i.u1)) +} + +func (i *instruction) setAmode(a *addressMode) { + i.u1 = uint64(uintptr(unsafe.Pointer(a))) +} + +func (i *instruction) asVecLoad1R(rd regalloc.VReg, rn operand, arr vecArrangement) { // NOTE: currently only has support for no-offset loads, though it is suspicious that // we would need to support offset load (that is only available for post-index). i.kind = vecLoad1R @@ -646,32 +662,32 @@ func (i *instruction) asVecLoad1R(rd, rn operand, arr vecArrangement) { func (i *instruction) asCSet(rd regalloc.VReg, mask bool, c condFlag) { i.kind = cSet - i.rd = operandNR(rd) + i.rd = rd i.u1 = uint64(c) if mask { i.u2 = 1 } } -func (i *instruction) asCSel(rd, rn, rm operand, c condFlag, _64bit bool) { +func (i *instruction) asCSel(rd regalloc.VReg, rn, rm operand, c condFlag, _64bit bool) { i.kind = cSel i.rd = rd i.rn = rn i.rm = rm i.u1 = uint64(c) if _64bit { - i.u3 = 1 + i.u2 = 1 } } -func (i *instruction) asFpuCSel(rd, rn, rm operand, c condFlag, _64bit bool) { +func (i *instruction) asFpuCSel(rd regalloc.VReg, rn, rm operand, c condFlag, _64bit bool) { i.kind = fpuCSel i.rd = rd i.rn = rn i.rm = rm i.u1 = uint64(c) if _64bit { - i.u3 = 1 + i.u2 = 1 } } @@ -691,7 +707,7 @@ func (i *instruction) asBrTableSequence(indexReg regalloc.VReg, targetIndex, tar } func (i *instruction) brTableSequenceOffsetsResolved() { - i.u3 = 1 // indicate that the offsets are resolved, for debugging. + i.rm.data = 1 // indicate that the offsets are resolved, for debugging. } func (i *instruction) brLabel() label { @@ -701,7 +717,7 @@ func (i *instruction) brLabel() label { // brOffsetResolved is called when the target label is resolved. func (i *instruction) brOffsetResolve(offset int64) { i.u2 = uint64(offset) - i.u3 = 1 // indicate that the offset is resolved, for debugging. + i.rm.data = 1 // indicate that the offset is resolved, for debugging. } func (i *instruction) brOffset() int64 { @@ -714,7 +730,7 @@ func (i *instruction) asCondBr(c cond, target label, is64bit bool) { i.u1 = c.asUint64() i.u2 = uint64(target) if is64bit { - i.u3 = 1 + i.u2 |= 1 << 32 } } @@ -728,17 +744,17 @@ func (i *instruction) condBrLabel() label { // condBrOffsetResolve is called when the target label is resolved. func (i *instruction) condBrOffsetResolve(offset int64) { - i.rd.data = uint64(offset) - i.rd.data2 = 1 // indicate that the offset is resolved, for debugging. + i.rn.data = uint64(offset) + i.rn.data2 = 1 // indicate that the offset is resolved, for debugging. } // condBrOffsetResolved returns true if condBrOffsetResolve is already called. func (i *instruction) condBrOffsetResolved() bool { - return i.rd.data2 == 1 + return i.rn.data2 == 1 } func (i *instruction) condBrOffset() int64 { - return int64(i.rd.data) + return int64(i.rn.data) } func (i *instruction) condBrCond() cond { @@ -746,33 +762,33 @@ func (i *instruction) condBrCond() cond { } func (i *instruction) condBr64bit() bool { - return i.u3 == 1 + return i.u2&(1<<32) != 0 } func (i *instruction) asLoadFpuConst32(rd regalloc.VReg, raw uint64) { i.kind = loadFpuConst32 i.u1 = raw - i.rd = operandNR(rd) + i.rd = rd } func (i *instruction) asLoadFpuConst64(rd regalloc.VReg, raw uint64) { i.kind = loadFpuConst64 i.u1 = raw - i.rd = operandNR(rd) + i.rd = rd } func (i *instruction) asLoadFpuConst128(rd regalloc.VReg, lo, hi uint64) { i.kind = loadFpuConst128 i.u1 = lo i.u2 = hi - i.rd = operandNR(rd) + i.rd = rd } func (i *instruction) asFpuCmp(rn, rm operand, is64bit bool) { i.kind = fpuCmp i.rn, i.rm = rn, rm if is64bit { - i.u3 = 1 + i.u1 = 1 } } @@ -783,12 +799,12 @@ func (i *instruction) asCCmpImm(rn operand, imm uint64, c condFlag, flag byte, i i.u1 = uint64(c) i.u2 = uint64(flag) if is64bit { - i.u3 = 1 + i.u2 |= 1 << 32 } } // asALU setups a basic ALU instruction. -func (i *instruction) asALU(aluOp aluOp, rd, rn, rm operand, dst64bit bool) { +func (i *instruction) asALU(aluOp aluOp, rd regalloc.VReg, rn, rm operand, dst64bit bool) { switch rm.kind { case operandKindNR: i.kind = aluRRR @@ -804,22 +820,22 @@ func (i *instruction) asALU(aluOp aluOp, rd, rn, rm operand, dst64bit bool) { i.u1 = uint64(aluOp) i.rd, i.rn, i.rm = rd, rn, rm if dst64bit { - i.u3 = 1 + i.u2 |= 1 << 32 } } // asALU setups a basic ALU instruction. -func (i *instruction) asALURRRR(aluOp aluOp, rd, rn, rm, ra operand, dst64bit bool) { +func (i *instruction) asALURRRR(aluOp aluOp, rd regalloc.VReg, rn, rm operand, ra regalloc.VReg, dst64bit bool) { i.kind = aluRRRR i.u1 = uint64(aluOp) - i.rd, i.rn, i.rm, i.ra = rd, rn, rm, ra + i.rd, i.rn, i.rm, i.u2 = rd, rn, rm, uint64(ra) if dst64bit { - i.u3 = 1 + i.u1 |= 1 << 32 } } // asALUShift setups a shift based ALU instruction. -func (i *instruction) asALUShift(aluOp aluOp, rd, rn, rm operand, dst64bit bool) { +func (i *instruction) asALUShift(aluOp aluOp, rd regalloc.VReg, rn, rm operand, dst64bit bool) { switch rm.kind { case operandKindNR: i.kind = aluRRR // If the shift amount op is a register, then the instruction is encoded as a normal ALU instruction with two register operands. @@ -831,17 +847,17 @@ func (i *instruction) asALUShift(aluOp aluOp, rd, rn, rm operand, dst64bit bool) i.u1 = uint64(aluOp) i.rd, i.rn, i.rm = rd, rn, rm if dst64bit { - i.u3 = 1 + i.u2 |= 1 << 32 } } func (i *instruction) asALUBitmaskImm(aluOp aluOp, rd, rn regalloc.VReg, imm uint64, dst64bit bool) { i.kind = aluRRBitmaskImm i.u1 = uint64(aluOp) - i.rn, i.rd = operandNR(rn), operandNR(rd) + i.rn, i.rd = operandNR(rn), rd i.u2 = imm if dst64bit { - i.u3 = 1 + i.u1 |= 1 << 32 } } @@ -852,76 +868,76 @@ func (i *instruction) asMovToFPSR(rn regalloc.VReg) { func (i *instruction) asMovFromFPSR(rd regalloc.VReg) { i.kind = movFromFPSR - i.rd = operandNR(rd) + i.rd = rd } func (i *instruction) asBitRR(bitOp bitOp, rd, rn regalloc.VReg, is64bit bool) { i.kind = bitRR - i.rn, i.rd = operandNR(rn), operandNR(rd) + i.rn, i.rd = operandNR(rn), rd i.u1 = uint64(bitOp) if is64bit { i.u2 = 1 } } -func (i *instruction) asFpuRRR(op fpuBinOp, rd, rn, rm operand, dst64bit bool) { +func (i *instruction) asFpuRRR(op fpuBinOp, rd regalloc.VReg, rn, rm operand, dst64bit bool) { i.kind = fpuRRR i.u1 = uint64(op) i.rd, i.rn, i.rm = rd, rn, rm if dst64bit { - i.u3 = 1 + i.u2 = 1 } } -func (i *instruction) asFpuRR(op fpuUniOp, rd, rn operand, dst64bit bool) { +func (i *instruction) asFpuRR(op fpuUniOp, rd regalloc.VReg, rn operand, dst64bit bool) { i.kind = fpuRR i.u1 = uint64(op) i.rd, i.rn = rd, rn if dst64bit { - i.u3 = 1 + i.u2 = 1 } } func (i *instruction) asExtend(rd, rn regalloc.VReg, fromBits, toBits byte, signed bool) { i.kind = extend - i.rn, i.rd = operandNR(rn), operandNR(rd) + i.rn, i.rd = operandNR(rn), rd i.u1 = uint64(fromBits) i.u2 = uint64(toBits) if signed { - i.u3 = 1 + i.u2 |= 1 << 32 } } func (i *instruction) asMove32(rd, rn regalloc.VReg) { i.kind = mov32 - i.rn, i.rd = operandNR(rn), operandNR(rd) + i.rn, i.rd = operandNR(rn), rd } func (i *instruction) asMove64(rd, rn regalloc.VReg) *instruction { i.kind = mov64 - i.rn, i.rd = operandNR(rn), operandNR(rd) + i.rn, i.rd = operandNR(rn), rd return i } func (i *instruction) asFpuMov64(rd, rn regalloc.VReg) { i.kind = fpuMov64 - i.rn, i.rd = operandNR(rn), operandNR(rd) + i.rn, i.rd = operandNR(rn), rd } func (i *instruction) asFpuMov128(rd, rn regalloc.VReg) *instruction { i.kind = fpuMov128 - i.rn, i.rd = operandNR(rn), operandNR(rd) + i.rn, i.rd = operandNR(rn), rd return i } -func (i *instruction) asMovToVec(rd, rn operand, arr vecArrangement, index vecIndex) { +func (i *instruction) asMovToVec(rd regalloc.VReg, rn operand, arr vecArrangement, index vecIndex) { i.kind = movToVec i.rd = rd i.rn = rn i.u1, i.u2 = uint64(arr), uint64(index) } -func (i *instruction) asMovFromVec(rd, rn operand, arr vecArrangement, index vecIndex, signed bool) { +func (i *instruction) asMovFromVec(rd regalloc.VReg, rn operand, arr vecArrangement, index vecIndex, signed bool) { if signed { i.kind = movFromVecSigned } else { @@ -932,48 +948,48 @@ func (i *instruction) asMovFromVec(rd, rn operand, arr vecArrangement, index vec i.u1, i.u2 = uint64(arr), uint64(index) } -func (i *instruction) asVecDup(rd, rn operand, arr vecArrangement) { +func (i *instruction) asVecDup(rd regalloc.VReg, rn operand, arr vecArrangement) { i.kind = vecDup i.u1 = uint64(arr) i.rn, i.rd = rn, rd } -func (i *instruction) asVecDupElement(rd, rn operand, arr vecArrangement, index vecIndex) { +func (i *instruction) asVecDupElement(rd regalloc.VReg, rn operand, arr vecArrangement, index vecIndex) { i.kind = vecDupElement i.u1 = uint64(arr) i.rn, i.rd = rn, rd i.u2 = uint64(index) } -func (i *instruction) asVecExtract(rd, rn, rm operand, arr vecArrangement, index uint32) { +func (i *instruction) asVecExtract(rd regalloc.VReg, rn, rm operand, arr vecArrangement, index uint32) { i.kind = vecExtract i.u1 = uint64(arr) i.rn, i.rm, i.rd = rn, rm, rd i.u2 = uint64(index) } -func (i *instruction) asVecMovElement(rd, rn operand, arr vecArrangement, rdIndex, rnIndex vecIndex) { +func (i *instruction) asVecMovElement(rd regalloc.VReg, rn operand, arr vecArrangement, rdIndex, rnIndex vecIndex) { i.kind = vecMovElement i.u1 = uint64(arr) - i.u2, i.u3 = uint64(rdIndex), uint64(rnIndex) + i.u2 = uint64(rdIndex) | uint64(rnIndex)<<32 i.rn, i.rd = rn, rd } -func (i *instruction) asVecMisc(op vecOp, rd, rn operand, arr vecArrangement) { +func (i *instruction) asVecMisc(op vecOp, rd regalloc.VReg, rn operand, arr vecArrangement) { i.kind = vecMisc i.u1 = uint64(op) i.rn, i.rd = rn, rd i.u2 = uint64(arr) } -func (i *instruction) asVecLanes(op vecOp, rd, rn operand, arr vecArrangement) { +func (i *instruction) asVecLanes(op vecOp, rd regalloc.VReg, rn operand, arr vecArrangement) { i.kind = vecLanes i.u1 = uint64(op) i.rn, i.rd = rn, rd i.u2 = uint64(arr) } -func (i *instruction) asVecShiftImm(op vecOp, rd, rn, rm operand, arr vecArrangement) *instruction { +func (i *instruction) asVecShiftImm(op vecOp, rd regalloc.VReg, rn, rm operand, arr vecArrangement) *instruction { i.kind = vecShiftImm i.u1 = uint64(op) i.rn, i.rm, i.rd = rn, rm, rd @@ -981,7 +997,7 @@ func (i *instruction) asVecShiftImm(op vecOp, rd, rn, rm operand, arr vecArrange return i } -func (i *instruction) asVecTbl(nregs byte, rd, rn, rm operand, arr vecArrangement) { +func (i *instruction) asVecTbl(nregs byte, rd regalloc.VReg, rn, rm operand, arr vecArrangement) { switch nregs { case 0, 1: i.kind = vecTbl @@ -1000,14 +1016,14 @@ func (i *instruction) asVecTbl(nregs byte, rd, rn, rm operand, arr vecArrangemen i.u2 = uint64(arr) } -func (i *instruction) asVecPermute(op vecOp, rd, rn, rm operand, arr vecArrangement) { +func (i *instruction) asVecPermute(op vecOp, rd regalloc.VReg, rn, rm operand, arr vecArrangement) { i.kind = vecPermute i.u1 = uint64(op) i.rn, i.rm, i.rd = rn, rm, rd i.u2 = uint64(arr) } -func (i *instruction) asVecRRR(op vecOp, rd, rn, rm operand, arr vecArrangement) *instruction { +func (i *instruction) asVecRRR(op vecOp, rd regalloc.VReg, rn, rm operand, arr vecArrangement) *instruction { i.kind = vecRRR i.u1 = uint64(op) i.rn, i.rd, i.rm = rn, rd, rm @@ -1017,7 +1033,7 @@ func (i *instruction) asVecRRR(op vecOp, rd, rn, rm operand, arr vecArrangement) // asVecRRRRewrite encodes a vector instruction that rewrites the destination register. // IMPORTANT: the destination register must be already defined before this instruction. -func (i *instruction) asVecRRRRewrite(op vecOp, rd, rn, rm operand, arr vecArrangement) { +func (i *instruction) asVecRRRRewrite(op vecOp, rd regalloc.VReg, rn, rm operand, arr vecArrangement) { i.kind = vecRRRRewrite i.u1 = uint64(op) i.rn, i.rd, i.rm = rn, rd, rm @@ -1033,8 +1049,8 @@ func (i *instruction) IsCopy() bool { // String implements fmt.Stringer. func (i *instruction) String() (str string) { - is64SizeBitToSize := func(u3 uint64) byte { - if u3 == 0 { + is64SizeBitToSize := func(v uint64) byte { + if v == 0 { return 32 } return 64 @@ -1049,46 +1065,46 @@ func (i *instruction) String() (str string) { str = "nop0" } case aluRRR: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2 >> 32) str = fmt.Sprintf("%s %s, %s, %s", aluOp(i.u1).String(), - formatVRegSized(i.rd.nr(), size), formatVRegSized(i.rn.nr(), size), + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), i.rm.format(size)) case aluRRRR: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u1 >> 32) str = fmt.Sprintf("%s %s, %s, %s, %s", aluOp(i.u1).String(), - formatVRegSized(i.rd.nr(), size), formatVRegSized(i.rn.nr(), size), formatVRegSized(i.rm.nr(), size), formatVRegSized(i.ra.nr(), size)) + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), formatVRegSized(i.rm.nr(), size), formatVRegSized(regalloc.VReg(i.u2), size)) case aluRRImm12: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2 >> 32) str = fmt.Sprintf("%s %s, %s, %s", aluOp(i.u1).String(), - formatVRegSized(i.rd.nr(), size), formatVRegSized(i.rn.nr(), size), i.rm.format(size)) + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), i.rm.format(size)) case aluRRBitmaskImm: - size := is64SizeBitToSize(i.u3) - rd, rn := formatVRegSized(i.rd.nr(), size), formatVRegSized(i.rn.nr(), size) + size := is64SizeBitToSize(i.u1 >> 32) + rd, rn := formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size) if size == 32 { str = fmt.Sprintf("%s %s, %s, #%#x", aluOp(i.u1).String(), rd, rn, uint32(i.u2)) } else { str = fmt.Sprintf("%s %s, %s, #%#x", aluOp(i.u1).String(), rd, rn, i.u2) } case aluRRImmShift: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2 >> 32) str = fmt.Sprintf("%s %s, %s, %#x", aluOp(i.u1).String(), - formatVRegSized(i.rd.nr(), size), + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), i.rm.shiftImm(), ) case aluRRRShift: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2 >> 32) str = fmt.Sprintf("%s %s, %s, %s", aluOp(i.u1).String(), - formatVRegSized(i.rd.nr(), size), + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), i.rm.format(size), ) case aluRRRExtend: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2 >> 32) str = fmt.Sprintf("%s %s, %s, %s", aluOp(i.u1).String(), - formatVRegSized(i.rd.nr(), size), + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), // Regardless of the source size, the register is formatted in 32-bit. i.rm.format(32), @@ -1097,57 +1113,57 @@ func (i *instruction) String() (str string) { size := is64SizeBitToSize(i.u2) str = fmt.Sprintf("%s %s, %s", bitOp(i.u1), - formatVRegSized(i.rd.nr(), size), + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), ) case uLoad8: - str = fmt.Sprintf("ldrb %s, %s", formatVRegSized(i.rd.nr(), 32), i.amode.format(32)) + str = fmt.Sprintf("ldrb %s, %s", formatVRegSized(i.rd, 32), i.getAmode().format(32)) case sLoad8: - str = fmt.Sprintf("ldrsb %s, %s", formatVRegSized(i.rd.nr(), 32), i.amode.format(32)) + str = fmt.Sprintf("ldrsb %s, %s", formatVRegSized(i.rd, 32), i.getAmode().format(32)) case uLoad16: - str = fmt.Sprintf("ldrh %s, %s", formatVRegSized(i.rd.nr(), 32), i.amode.format(32)) + str = fmt.Sprintf("ldrh %s, %s", formatVRegSized(i.rd, 32), i.getAmode().format(32)) case sLoad16: - str = fmt.Sprintf("ldrsh %s, %s", formatVRegSized(i.rd.nr(), 32), i.amode.format(32)) + str = fmt.Sprintf("ldrsh %s, %s", formatVRegSized(i.rd, 32), i.getAmode().format(32)) case uLoad32: - str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd.nr(), 32), i.amode.format(32)) + str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd, 32), i.getAmode().format(32)) case sLoad32: - str = fmt.Sprintf("ldrs %s, %s", formatVRegSized(i.rd.nr(), 32), i.amode.format(32)) + str = fmt.Sprintf("ldrs %s, %s", formatVRegSized(i.rd, 32), i.getAmode().format(32)) case uLoad64: - str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd.nr(), 64), i.amode.format(64)) + str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd, 64), i.getAmode().format(64)) case store8: - str = fmt.Sprintf("strb %s, %s", formatVRegSized(i.rn.nr(), 32), i.amode.format(8)) + str = fmt.Sprintf("strb %s, %s", formatVRegSized(i.rn.nr(), 32), i.getAmode().format(8)) case store16: - str = fmt.Sprintf("strh %s, %s", formatVRegSized(i.rn.nr(), 32), i.amode.format(16)) + str = fmt.Sprintf("strh %s, %s", formatVRegSized(i.rn.nr(), 32), i.getAmode().format(16)) case store32: - str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 32), i.amode.format(32)) + str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 32), i.getAmode().format(32)) case store64: - str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 64), i.amode.format(64)) + str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 64), i.getAmode().format(64)) case storeP64: str = fmt.Sprintf("stp %s, %s, %s", - formatVRegSized(i.rn.nr(), 64), formatVRegSized(i.rm.nr(), 64), i.amode.format(64)) + formatVRegSized(i.rn.nr(), 64), formatVRegSized(i.rm.nr(), 64), i.getAmode().format(64)) case loadP64: str = fmt.Sprintf("ldp %s, %s, %s", - formatVRegSized(i.rn.nr(), 64), formatVRegSized(i.rm.nr(), 64), i.amode.format(64)) + formatVRegSized(i.rn.nr(), 64), formatVRegSized(i.rm.nr(), 64), i.getAmode().format(64)) case mov64: str = fmt.Sprintf("mov %s, %s", - formatVRegSized(i.rd.nr(), 64), + formatVRegSized(i.rd, 64), formatVRegSized(i.rn.nr(), 64)) case mov32: - str = fmt.Sprintf("mov %s, %s", formatVRegSized(i.rd.nr(), 32), formatVRegSized(i.rn.nr(), 32)) + str = fmt.Sprintf("mov %s, %s", formatVRegSized(i.rd, 32), formatVRegSized(i.rn.nr(), 32)) case movZ: - size := is64SizeBitToSize(i.u3) - str = fmt.Sprintf("movz %s, #%#x, lsl %d", formatVRegSized(i.rd.nr(), size), uint16(i.u1), i.u2*16) + size := is64SizeBitToSize(i.u2 >> 32) + str = fmt.Sprintf("movz %s, #%#x, lsl %d", formatVRegSized(i.rd, size), uint16(i.u1), uint32(i.u2)*16) case movN: - size := is64SizeBitToSize(i.u3) - str = fmt.Sprintf("movn %s, #%#x, lsl %d", formatVRegSized(i.rd.nr(), size), uint16(i.u1), i.u2*16) + size := is64SizeBitToSize(i.u2 >> 32) + str = fmt.Sprintf("movn %s, #%#x, lsl %d", formatVRegSized(i.rd, size), uint16(i.u1), uint32(i.u2)*16) case movK: - size := is64SizeBitToSize(i.u3) - str = fmt.Sprintf("movk %s, #%#x, lsl %d", formatVRegSized(i.rd.nr(), size), uint16(i.u1), i.u2*16) + size := is64SizeBitToSize(i.u2 >> 32) + str = fmt.Sprintf("movk %s, #%#x, lsl %d", formatVRegSized(i.rd, size), uint16(i.u1), uint32(i.u2)*16) case extend: fromBits, toBits := byte(i.u1), byte(i.u2) var signedStr string - if i.u3 == 1 { + if i.u2>>32 == 1 { signedStr = "s" } else { signedStr = "u" @@ -1161,39 +1177,39 @@ func (i *instruction) String() (str string) { case 32: fromStr = "w" } - str = fmt.Sprintf("%sxt%s %s, %s", signedStr, fromStr, formatVRegSized(i.rd.nr(), toBits), formatVRegSized(i.rn.nr(), 32)) + str = fmt.Sprintf("%sxt%s %s, %s", signedStr, fromStr, formatVRegSized(i.rd, toBits), formatVRegSized(i.rn.nr(), 32)) case cSel: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2) str = fmt.Sprintf("csel %s, %s, %s, %s", - formatVRegSized(i.rd.nr(), size), + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), formatVRegSized(i.rm.nr(), size), condFlag(i.u1), ) case cSet: if i.u2 != 0 { - str = fmt.Sprintf("csetm %s, %s", formatVRegSized(i.rd.nr(), 64), condFlag(i.u1)) + str = fmt.Sprintf("csetm %s, %s", formatVRegSized(i.rd, 64), condFlag(i.u1)) } else { - str = fmt.Sprintf("cset %s, %s", formatVRegSized(i.rd.nr(), 64), condFlag(i.u1)) + str = fmt.Sprintf("cset %s, %s", formatVRegSized(i.rd, 64), condFlag(i.u1)) } case cCmpImm: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2 >> 32) str = fmt.Sprintf("ccmp %s, #%#x, #%#x, %s", formatVRegSized(i.rn.nr(), size), i.rm.data, i.u2&0b1111, condFlag(i.u1)) case fpuMov64: str = fmt.Sprintf("mov %s, %s", - formatVRegVec(i.rd.nr(), vecArrangement8B, vecIndexNone), + formatVRegVec(i.rd, vecArrangement8B, vecIndexNone), formatVRegVec(i.rn.nr(), vecArrangement8B, vecIndexNone)) case fpuMov128: str = fmt.Sprintf("mov %s, %s", - formatVRegVec(i.rd.nr(), vecArrangement16B, vecIndexNone), + formatVRegVec(i.rd, vecArrangement16B, vecIndexNone), formatVRegVec(i.rn.nr(), vecArrangement16B, vecIndexNone)) case fpuMovFromVec: panic("TODO") case fpuRR: - dstSz := is64SizeBitToSize(i.u3) + dstSz := is64SizeBitToSize(i.u2) srcSz := dstSz op := fpuUniOp(i.u1) switch op { @@ -1203,38 +1219,38 @@ func (i *instruction) String() (str string) { srcSz = 64 } str = fmt.Sprintf("%s %s, %s", op.String(), - formatVRegSized(i.rd.nr(), dstSz), formatVRegSized(i.rn.nr(), srcSz)) + formatVRegSized(i.rd, dstSz), formatVRegSized(i.rn.nr(), srcSz)) case fpuRRR: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2) str = fmt.Sprintf("%s %s, %s, %s", fpuBinOp(i.u1).String(), - formatVRegSized(i.rd.nr(), size), formatVRegSized(i.rn.nr(), size), formatVRegSized(i.rm.nr(), size)) + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), formatVRegSized(i.rm.nr(), size)) case fpuRRI: panic("TODO") case fpuRRRR: panic("TODO") case fpuCmp: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u1) str = fmt.Sprintf("fcmp %s, %s", formatVRegSized(i.rn.nr(), size), formatVRegSized(i.rm.nr(), size)) case fpuLoad32: - str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd.nr(), 32), i.amode.format(32)) + str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd, 32), i.getAmode().format(32)) case fpuStore32: - str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 32), i.amode.format(64)) + str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 32), i.getAmode().format(64)) case fpuLoad64: - str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd.nr(), 64), i.amode.format(64)) + str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd, 64), i.getAmode().format(64)) case fpuStore64: - str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 64), i.amode.format(64)) + str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 64), i.getAmode().format(64)) case fpuLoad128: - str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd.nr(), 128), i.amode.format(64)) + str = fmt.Sprintf("ldr %s, %s", formatVRegSized(i.rd, 128), i.getAmode().format(64)) case fpuStore128: - str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 128), i.amode.format(64)) + str = fmt.Sprintf("str %s, %s", formatVRegSized(i.rn.nr(), 128), i.getAmode().format(64)) case loadFpuConst32: - str = fmt.Sprintf("ldr %s, #8; b 8; data.f32 %f", formatVRegSized(i.rd.nr(), 32), math.Float32frombits(uint32(i.u1))) + str = fmt.Sprintf("ldr %s, #8; b 8; data.f32 %f", formatVRegSized(i.rd, 32), math.Float32frombits(uint32(i.u1))) case loadFpuConst64: - str = fmt.Sprintf("ldr %s, #8; b 16; data.f64 %f", formatVRegSized(i.rd.nr(), 64), math.Float64frombits(i.u1)) + str = fmt.Sprintf("ldr %s, #8; b 16; data.f64 %f", formatVRegSized(i.rd, 64), math.Float64frombits(i.u1)) case loadFpuConst128: str = fmt.Sprintf("ldr %s, #8; b 32; data.v128 %016x %016x", - formatVRegSized(i.rd.nr(), 128), i.u1, i.u2) + formatVRegSized(i.rd, 128), i.u1, i.u2) case fpuToInt: var op, src, dst string if signed := i.u1 == 1; signed { @@ -1242,15 +1258,15 @@ func (i *instruction) String() (str string) { } else { op = "fcvtzu" } - if src64 := i.u2 == 1; src64 { + if src64 := i.u2&1 != 0; src64 { src = formatVRegWidthVec(i.rn.nr(), vecArrangementD) } else { src = formatVRegWidthVec(i.rn.nr(), vecArrangementS) } - if dst64 := i.u3 == 1; dst64 { - dst = formatVRegSized(i.rd.nr(), 64) + if dst64 := i.u2&2 != 0; dst64 { + dst = formatVRegSized(i.rd, 64) } else { - dst = formatVRegSized(i.rd.nr(), 32) + dst = formatVRegSized(i.rd, 32) } str = fmt.Sprintf("%s %s, %s", op, dst, src) @@ -1261,21 +1277,21 @@ func (i *instruction) String() (str string) { } else { op = "ucvtf" } - if src64 := i.u2 == 1; src64 { + if src64 := i.u2&1 != 0; src64 { src = formatVRegSized(i.rn.nr(), 64) } else { src = formatVRegSized(i.rn.nr(), 32) } - if dst64 := i.u3 == 1; dst64 { - dst = formatVRegWidthVec(i.rd.nr(), vecArrangementD) + if dst64 := i.u2&2 != 0; dst64 { + dst = formatVRegWidthVec(i.rd, vecArrangementD) } else { - dst = formatVRegWidthVec(i.rd.nr(), vecArrangementS) + dst = formatVRegWidthVec(i.rd, vecArrangementS) } str = fmt.Sprintf("%s %s, %s", op, dst, src) case fpuCSel: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2) str = fmt.Sprintf("fcsel %s, %s, %s, %s", - formatVRegSized(i.rd.nr(), size), + formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), size), formatVRegSized(i.rm.nr(), size), condFlag(i.u1), @@ -1291,7 +1307,7 @@ func (i *instruction) String() (str string) { default: panic("unsupported arrangement " + arr.String()) } - str = fmt.Sprintf("ins %s, %s", formatVRegVec(i.rd.nr(), arr, vecIndex(i.u2)), formatVRegSized(i.rn.nr(), size)) + str = fmt.Sprintf("ins %s, %s", formatVRegVec(i.rd, arr, vecIndex(i.u2)), formatVRegSized(i.rn.nr(), size)) case movFromVec, movFromVecSigned: var size byte var opcode string @@ -1315,23 +1331,23 @@ func (i *instruction) String() (str string) { default: panic("unsupported arrangement " + arr.String()) } - str = fmt.Sprintf("%s %s, %s", opcode, formatVRegSized(i.rd.nr(), size), formatVRegVec(i.rn.nr(), arr, vecIndex(i.u2))) + str = fmt.Sprintf("%s %s, %s", opcode, formatVRegSized(i.rd, size), formatVRegVec(i.rn.nr(), arr, vecIndex(i.u2))) case vecDup: str = fmt.Sprintf("dup %s, %s", - formatVRegVec(i.rd.nr(), vecArrangement(i.u1), vecIndexNone), + formatVRegVec(i.rd, vecArrangement(i.u1), vecIndexNone), formatVRegSized(i.rn.nr(), 64), ) case vecDupElement: arr := vecArrangement(i.u1) str = fmt.Sprintf("dup %s, %s", - formatVRegVec(i.rd.nr(), arr, vecIndexNone), + formatVRegVec(i.rd, arr, vecIndexNone), formatVRegVec(i.rn.nr(), arr, vecIndex(i.u2)), ) case vecDupFromFpu: panic("TODO") case vecExtract: str = fmt.Sprintf("ext %s, %s, %s, #%d", - formatVRegVec(i.rd.nr(), vecArrangement(i.u1), vecIndexNone), + formatVRegVec(i.rd, vecArrangement(i.u1), vecIndexNone), formatVRegVec(i.rn.nr(), vecArrangement(i.u1), vecIndexNone), formatVRegVec(i.rm.nr(), vecArrangement(i.u1), vecIndexNone), uint32(i.u2), @@ -1340,15 +1356,15 @@ func (i *instruction) String() (str string) { panic("TODO") case vecMovElement: str = fmt.Sprintf("mov %s, %s", - formatVRegVec(i.rd.nr(), vecArrangement(i.u1), vecIndex(i.u2)), - formatVRegVec(i.rn.nr(), vecArrangement(i.u1), vecIndex(i.u3)), + formatVRegVec(i.rd, vecArrangement(i.u1), vecIndex(i.u2&0xffffffff)), + formatVRegVec(i.rn.nr(), vecArrangement(i.u1), vecIndex(i.u2>>32)), ) case vecMiscNarrow: panic("TODO") case vecRRR, vecRRRRewrite: str = fmt.Sprintf("%s %s, %s, %s", vecOp(i.u1), - formatVRegVec(i.rd.nr(), vecArrangement(i.u2), vecIndexNone), + formatVRegVec(i.rd, vecArrangement(i.u2), vecIndexNone), formatVRegVec(i.rn.nr(), vecArrangement(i.u2), vecIndexNone), formatVRegVec(i.rm.nr(), vecArrangement(i.u2), vecIndexNone), ) @@ -1356,12 +1372,12 @@ func (i *instruction) String() (str string) { vop := vecOp(i.u1) if vop == vecOpCmeq0 { str = fmt.Sprintf("cmeq %s, %s, #0", - formatVRegVec(i.rd.nr(), vecArrangement(i.u2), vecIndexNone), + formatVRegVec(i.rd, vecArrangement(i.u2), vecIndexNone), formatVRegVec(i.rn.nr(), vecArrangement(i.u2), vecIndexNone)) } else { str = fmt.Sprintf("%s %s, %s", vop, - formatVRegVec(i.rd.nr(), vecArrangement(i.u2), vecIndexNone), + formatVRegVec(i.rd, vecArrangement(i.u2), vecIndexNone), formatVRegVec(i.rn.nr(), vecArrangement(i.u2), vecIndexNone)) } case vecLanes: @@ -1379,24 +1395,24 @@ func (i *instruction) String() (str string) { } str = fmt.Sprintf("%s %s, %s", vecOp(i.u1), - formatVRegWidthVec(i.rd.nr(), destArr), + formatVRegWidthVec(i.rd, destArr), formatVRegVec(i.rn.nr(), arr, vecIndexNone)) case vecShiftImm: arr := vecArrangement(i.u2) str = fmt.Sprintf("%s %s, %s, #%d", vecOp(i.u1), - formatVRegVec(i.rd.nr(), arr, vecIndexNone), + formatVRegVec(i.rd, arr, vecIndexNone), formatVRegVec(i.rn.nr(), arr, vecIndexNone), i.rm.shiftImm()) case vecTbl: arr := vecArrangement(i.u2) str = fmt.Sprintf("tbl %s, { %s }, %s", - formatVRegVec(i.rd.nr(), arr, vecIndexNone), + formatVRegVec(i.rd, arr, vecIndexNone), formatVRegVec(i.rn.nr(), vecArrangement16B, vecIndexNone), formatVRegVec(i.rm.nr(), arr, vecIndexNone)) case vecTbl2: arr := vecArrangement(i.u2) - rd, rn, rm := i.rd.nr(), i.rn.nr(), i.rm.nr() + rd, rn, rm := i.rd, i.rn.nr(), i.rm.nr() rn1 := regalloc.FromRealReg(rn.RealReg()+1, rn.RegType()) str = fmt.Sprintf("tbl %s, { %s, %s }, %s", formatVRegVec(rd, arr, vecIndexNone), @@ -1407,13 +1423,13 @@ func (i *instruction) String() (str string) { arr := vecArrangement(i.u2) str = fmt.Sprintf("%s %s, %s, %s", vecOp(i.u1), - formatVRegVec(i.rd.nr(), arr, vecIndexNone), + formatVRegVec(i.rd, arr, vecIndexNone), formatVRegVec(i.rn.nr(), arr, vecIndexNone), formatVRegVec(i.rm.nr(), arr, vecIndexNone)) case movToFPSR: str = fmt.Sprintf("msr fpsr, %s", formatVRegSized(i.rn.nr(), 64)) case movFromFPSR: - str = fmt.Sprintf("mrs %s fpsr", formatVRegSized(i.rd.nr(), 64)) + str = fmt.Sprintf("mrs %s fpsr", formatVRegSized(i.rd, 64)) case call: str = fmt.Sprintf("bl %s", ssa.FuncRef(i.u1)) case callInd: @@ -1422,15 +1438,15 @@ func (i *instruction) String() (str string) { str = "ret" case br: target := label(i.u1) - if i.u3 != 0 { + if i.rm.data != 0 { str = fmt.Sprintf("b #%#x (%s)", i.brOffset(), target.String()) } else { str = fmt.Sprintf("b %s", target.String()) } case condBr: - size := is64SizeBitToSize(i.u3) + size := is64SizeBitToSize(i.u2 >> 32) c := cond(i.u1) - target := label(i.u2) + target := label(i.u2 & 0xffffffff) switch c.kind() { case condKindRegisterZero: if !i.condBrOffsetResolved() { @@ -1456,7 +1472,7 @@ func (i *instruction) String() (str string) { } } case adr: - str = fmt.Sprintf("adr %s, #%#x", formatVRegSized(i.rd.nr(), 64), int64(i.u1)) + str = fmt.Sprintf("adr %s, #%#x", formatVRegSized(i.rd, 64), int64(i.u1)) case brTableSequence: targetIndex := i.u1 str = fmt.Sprintf("br_table_sequence %s, table_index=%d", formatVRegSized(i.rn.nr(), 64), targetIndex) @@ -1473,7 +1489,7 @@ func (i *instruction) String() (str string) { case 1: m = m + "b" } - str = fmt.Sprintf("%s %s, %s, %s", m, formatVRegSized(i.rm.nr(), size), formatVRegSized(i.rd.nr(), size), formatVRegSized(i.rn.nr(), 64)) + str = fmt.Sprintf("%s %s, %s, %s", m, formatVRegSized(i.rm.nr(), size), formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), 64)) case atomicCas: m := "casal" size := byte(32) @@ -1485,7 +1501,7 @@ func (i *instruction) String() (str string) { case 1: m = m + "b" } - str = fmt.Sprintf("%s %s, %s, %s", m, formatVRegSized(i.rd.nr(), size), formatVRegSized(i.rm.nr(), size), formatVRegSized(i.rn.nr(), 64)) + str = fmt.Sprintf("%s %s, %s, %s", m, formatVRegSized(i.rd, size), formatVRegSized(i.rm.nr(), size), formatVRegSized(i.rn.nr(), 64)) case atomicLoad: m := "ldar" size := byte(32) @@ -1497,7 +1513,7 @@ func (i *instruction) String() (str string) { case 1: m = m + "b" } - str = fmt.Sprintf("%s %s, %s", m, formatVRegSized(i.rd.nr(), size), formatVRegSized(i.rn.nr(), 64)) + str = fmt.Sprintf("%s %s, %s", m, formatVRegSized(i.rd, size), formatVRegSized(i.rn.nr(), 64)) case atomicStore: m := "stlr" size := byte(32) @@ -1517,9 +1533,9 @@ func (i *instruction) String() (str string) { case emitSourceOffsetInfo: str = fmt.Sprintf("source_offset_info %d", ssa.SourceOffset(i.u1)) case vecLoad1R: - str = fmt.Sprintf("ld1r {%s}, [%s]", formatVRegVec(i.rd.nr(), vecArrangement(i.u1), vecIndexNone), formatVRegSized(i.rn.nr(), 64)) + str = fmt.Sprintf("ld1r {%s}, [%s]", formatVRegVec(i.rd, vecArrangement(i.u1), vecIndexNone), formatVRegSized(i.rn.nr(), 64)) case loadConstBlockArg: - str = fmt.Sprintf("load_const_block_arg %s, %#x", formatVRegSized(i.rd.nr(), 64), i.u1) + str = fmt.Sprintf("load_const_block_arg %s, %#x", formatVRegSized(i.rd, 64), i.u1) default: panic(i.kind) } @@ -1528,26 +1544,26 @@ func (i *instruction) String() (str string) { func (i *instruction) asAdr(rd regalloc.VReg, offset int64) { i.kind = adr - i.rd = operandNR(rd) + i.rd = rd i.u1 = uint64(offset) } -func (i *instruction) asAtomicRmw(op atomicRmwOp, rn, rs, rt operand, size uint64) { +func (i *instruction) asAtomicRmw(op atomicRmwOp, rn, rs, rt regalloc.VReg, size uint64) { i.kind = atomicRmw - i.rd, i.rn, i.rm = rt, rn, rs + i.rd, i.rn, i.rm = rt, operandNR(rn), operandNR(rs) i.u1 = uint64(op) i.u2 = size } -func (i *instruction) asAtomicCas(rn, rs, rt operand, size uint64) { +func (i *instruction) asAtomicCas(rn, rs, rt regalloc.VReg, size uint64) { i.kind = atomicCas - i.rm, i.rn, i.rd = rt, rn, rs + i.rm, i.rn, i.rd = operandNR(rt), operandNR(rn), rs i.u2 = size } -func (i *instruction) asAtomicLoad(rn, rt operand, size uint64) { +func (i *instruction) asAtomicLoad(rn, rt regalloc.VReg, size uint64) { i.kind = atomicLoad - i.rn, i.rd = rn, rt + i.rn, i.rd = operandNR(rn), rt i.u2 = size } @@ -1755,12 +1771,12 @@ func (i *instruction) asLoadConstBlockArg(v uint64, typ ssa.Type, dst regalloc.V i.kind = loadConstBlockArg i.u1 = v i.u2 = uint64(typ) - i.rd = operandNR(dst) + i.rd = dst return i } func (i *instruction) loadConstBlockArgData() (v uint64, typ ssa.Type, dst regalloc.VReg) { - return i.u1, ssa.Type(i.u2), i.rd.nr() + return i.u1, ssa.Type(i.u2), i.rd } func (i *instruction) asEmitSourceOffsetInfo(l ssa.SourceOffset) *instruction { @@ -1778,7 +1794,7 @@ func (i *instruction) asUDF() *instruction { return i } -func (i *instruction) asFpuToInt(rd, rn operand, rdSigned, src64bit, dst64bit bool) { +func (i *instruction) asFpuToInt(rd regalloc.VReg, rn operand, rdSigned, src64bit, dst64bit bool) { i.kind = fpuToInt i.rn = rn i.rd = rd @@ -1789,11 +1805,11 @@ func (i *instruction) asFpuToInt(rd, rn operand, rdSigned, src64bit, dst64bit bo i.u2 = 1 } if dst64bit { - i.u3 = 1 + i.u2 |= 2 } } -func (i *instruction) asIntToFpu(rd, rn operand, rnSigned, src64bit, dst64bit bool) { +func (i *instruction) asIntToFpu(rd regalloc.VReg, rn operand, rnSigned, src64bit, dst64bit bool) { i.kind = intToFpu i.rn = rn i.rd = rd @@ -1804,7 +1820,7 @@ func (i *instruction) asIntToFpu(rd, rn operand, rnSigned, src64bit, dst64bit bo i.u2 = 1 } if dst64bit { - i.u3 = 1 + i.u2 |= 2 } } @@ -1817,7 +1833,7 @@ func (i *instruction) asExitSequence(ctx regalloc.VReg) *instruction { // aluOp determines the type of ALU operation. Instructions whose kind is one of // aluRRR, aluRRRR, aluRRImm12, aluRRBitmaskImm, aluRRImmShift, aluRRRShift and aluRRRExtend // would use this type. -type aluOp int +type aluOp uint32 func (a aluOp) String() string { switch a { diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/instr_encoding.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/instr_encoding.go index 227a964741..f0ede2d6aa 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/instr_encoding.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/instr_encoding.go @@ -44,12 +44,12 @@ func (i *instruction) encode(m *machine) { case callInd: c.Emit4Bytes(encodeUnconditionalBranchReg(regNumberInEncoding[i.rn.realReg()], true)) case store8, store16, store32, store64, fpuStore32, fpuStore64, fpuStore128: - c.Emit4Bytes(encodeLoadOrStore(i.kind, regNumberInEncoding[i.rn.realReg()], i.amode)) + c.Emit4Bytes(encodeLoadOrStore(i.kind, regNumberInEncoding[i.rn.realReg()], *i.getAmode())) case uLoad8, uLoad16, uLoad32, uLoad64, sLoad8, sLoad16, sLoad32, fpuLoad32, fpuLoad64, fpuLoad128: - c.Emit4Bytes(encodeLoadOrStore(i.kind, regNumberInEncoding[i.rd.realReg()], i.amode)) + c.Emit4Bytes(encodeLoadOrStore(i.kind, regNumberInEncoding[i.rd.RealReg()], *i.getAmode())) case vecLoad1R: c.Emit4Bytes(encodeVecLoad1R( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], vecArrangement(i.u1))) case condBr: @@ -75,22 +75,22 @@ func (i *instruction) encode(m *machine) { panic("BUG") } case movN: - c.Emit4Bytes(encodeMoveWideImmediate(0b00, regNumberInEncoding[i.rd.realReg()], i.u1, i.u2, i.u3)) + c.Emit4Bytes(encodeMoveWideImmediate(0b00, regNumberInEncoding[i.rd.RealReg()], i.u1, uint32(i.u2), uint32(i.u2>>32))) case movZ: - c.Emit4Bytes(encodeMoveWideImmediate(0b10, regNumberInEncoding[i.rd.realReg()], i.u1, i.u2, i.u3)) + c.Emit4Bytes(encodeMoveWideImmediate(0b10, regNumberInEncoding[i.rd.RealReg()], i.u1, uint32(i.u2), uint32(i.u2>>32))) case movK: - c.Emit4Bytes(encodeMoveWideImmediate(0b11, regNumberInEncoding[i.rd.realReg()], i.u1, i.u2, i.u3)) + c.Emit4Bytes(encodeMoveWideImmediate(0b11, regNumberInEncoding[i.rd.RealReg()], i.u1, uint32(i.u2), uint32(i.u2>>32))) case mov32: - to, from := i.rd.realReg(), i.rn.realReg() + to, from := i.rd.RealReg(), i.rn.realReg() c.Emit4Bytes(encodeAsMov32(regNumberInEncoding[from], regNumberInEncoding[to])) case mov64: - to, from := i.rd.realReg(), i.rn.realReg() + to, from := i.rd.RealReg(), i.rn.realReg() toIsSp := to == sp fromIsSp := from == sp c.Emit4Bytes(encodeMov64(regNumberInEncoding[to], regNumberInEncoding[from], toIsSp, fromIsSp)) case loadP64, storeP64: rt, rt2 := regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()] - amode := i.amode + amode := i.getAmode() rn := regNumberInEncoding[amode.rn.RealReg()] var pre bool switch amode.kind { @@ -102,21 +102,21 @@ func (i *instruction) encode(m *machine) { } c.Emit4Bytes(encodePreOrPostIndexLoadStorePair64(pre, kind == loadP64, rn, rt, rt2, amode.imm)) case loadFpuConst32: - rd := regNumberInEncoding[i.rd.realReg()] + rd := regNumberInEncoding[i.rd.RealReg()] if i.u1 == 0 { c.Emit4Bytes(encodeVecRRR(vecOpEOR, rd, rd, rd, vecArrangement8B)) } else { encodeLoadFpuConst32(c, rd, i.u1) } case loadFpuConst64: - rd := regNumberInEncoding[i.rd.realReg()] + rd := regNumberInEncoding[i.rd.RealReg()] if i.u1 == 0 { c.Emit4Bytes(encodeVecRRR(vecOpEOR, rd, rd, rd, vecArrangement8B)) } else { - encodeLoadFpuConst64(c, regNumberInEncoding[i.rd.realReg()], i.u1) + encodeLoadFpuConst64(c, regNumberInEncoding[i.rd.RealReg()], i.u1) } case loadFpuConst128: - rd := regNumberInEncoding[i.rd.realReg()] + rd := regNumberInEncoding[i.rd.RealReg()] lo, hi := i.u1, i.u2 if lo == 0 && hi == 0 { c.Emit4Bytes(encodeVecRRR(vecOpEOR, rd, rd, rd, vecArrangement16B)) @@ -126,35 +126,35 @@ func (i *instruction) encode(m *machine) { case aluRRRR: c.Emit4Bytes(encodeAluRRRR( aluOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], - regNumberInEncoding[i.ra.realReg()], - uint32(i.u3), + regNumberInEncoding[regalloc.VReg(i.u2).RealReg()], + uint32(i.u1>>32), )) case aluRRImmShift: c.Emit4Bytes(encodeAluRRImm( aluOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], uint32(i.rm.shiftImm()), - uint32(i.u3), + uint32(i.u2>>32), )) case aluRRR: rn := i.rn.realReg() c.Emit4Bytes(encodeAluRRR( aluOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[rn], regNumberInEncoding[i.rm.realReg()], - i.u3 == 1, + i.u2>>32 == 1, rn == sp, )) case aluRRRExtend: rm, exo, to := i.rm.er() c.Emit4Bytes(encodeAluRRRExtend( aluOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[rm.RealReg()], exo, @@ -164,25 +164,25 @@ func (i *instruction) encode(m *machine) { r, amt, sop := i.rm.sr() c.Emit4Bytes(encodeAluRRRShift( aluOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[r.RealReg()], uint32(amt), sop, - i.u3 == 1, + i.u2>>32 == 1, )) case aluRRBitmaskImm: c.Emit4Bytes(encodeAluBitmaskImmediate( aluOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], i.u2, - i.u3 == 1, + i.u1>>32 == 1, )) case bitRR: c.Emit4Bytes(encodeBitRR( bitOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], uint32(i.u2)), ) @@ -190,22 +190,22 @@ func (i *instruction) encode(m *machine) { imm12, shift := i.rm.imm12() c.Emit4Bytes(encodeAluRRImm12( aluOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], imm12, shift, - i.u3 == 1, + i.u2>>32 == 1, )) case fpuRRR: c.Emit4Bytes(encodeFpuRRR( fpuBinOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], - i.u3 == 1, + i.u2 == 1, )) case fpuMov64, fpuMov128: // https://developer.arm.com/documentation/ddi0596/2021-12/SIMD-FP-Instructions/MOV--vector---Move-vector--an-alias-of-ORR--vector--register-- - rd := regNumberInEncoding[i.rd.realReg()] + rd := regNumberInEncoding[i.rd.RealReg()] rn := regNumberInEncoding[i.rn.realReg()] var q uint32 if kind == fpuMov128 { @@ -213,7 +213,7 @@ func (i *instruction) encode(m *machine) { } c.Emit4Bytes(q<<30 | 0b1110101<<21 | rn<<16 | 0b000111<<10 | rn<<5 | rd) case cSet: - rd := regNumberInEncoding[i.rd.realReg()] + rd := regNumberInEncoding[i.rd.RealReg()] cf := condFlag(i.u1) if i.u2 == 1 { // https://developer.arm.com/documentation/ddi0602/2022-03/Base-Instructions/CSETM--Conditional-Set-Mask--an-alias-of-CSINV- @@ -225,12 +225,12 @@ func (i *instruction) encode(m *machine) { c.Emit4Bytes(0b1001101010011111<<16 | uint32(cf.invert())<<12 | 0b111111<<5 | rd) } case extend: - c.Emit4Bytes(encodeExtend(i.u3 == 1, byte(i.u1), byte(i.u2), regNumberInEncoding[i.rd.realReg()], regNumberInEncoding[i.rn.realReg()])) + c.Emit4Bytes(encodeExtend((i.u2>>32) == 1, byte(i.u1), byte(i.u2), regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()])) case fpuCmp: // https://developer.arm.com/documentation/ddi0596/2020-12/SIMD-FP-Instructions/FCMP--Floating-point-quiet-Compare--scalar--?lang=en rn, rm := regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()] var ftype uint32 - if i.u3 == 1 { + if i.u1 == 1 { ftype = 0b01 // double precision. } c.Emit4Bytes(0b1111<<25 | ftype<<22 | 1<<21 | rm<<16 | 0b1<<13 | rn<<5) @@ -242,34 +242,34 @@ func (i *instruction) encode(m *machine) { c.Emit4Bytes(0) } case adr: - c.Emit4Bytes(encodeAdr(regNumberInEncoding[i.rd.realReg()], uint32(i.u1))) + c.Emit4Bytes(encodeAdr(regNumberInEncoding[i.rd.RealReg()], uint32(i.u1))) case cSel: c.Emit4Bytes(encodeConditionalSelect( kind, - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], condFlag(i.u1), - i.u3 == 1, + i.u2 == 1, )) case fpuCSel: c.Emit4Bytes(encodeFpuCSel( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], condFlag(i.u1), - i.u3 == 1, + i.u2 == 1, )) case movToVec: c.Emit4Bytes(encodeMoveToVec( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], vecArrangement(byte(i.u1)), vecIndex(i.u2), )) case movFromVec, movFromVecSigned: c.Emit4Bytes(encodeMoveFromVec( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], vecArrangement(byte(i.u1)), vecIndex(i.u2), @@ -277,18 +277,18 @@ func (i *instruction) encode(m *machine) { )) case vecDup: c.Emit4Bytes(encodeVecDup( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], vecArrangement(byte(i.u1)))) case vecDupElement: c.Emit4Bytes(encodeVecDupElement( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], vecArrangement(byte(i.u1)), vecIndex(i.u2))) case vecExtract: c.Emit4Bytes(encodeVecExtract( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], vecArrangement(byte(i.u1)), @@ -296,35 +296,35 @@ func (i *instruction) encode(m *machine) { case vecPermute: c.Emit4Bytes(encodeVecPermute( vecOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], vecArrangement(byte(i.u2)))) case vecMovElement: c.Emit4Bytes(encodeVecMovElement( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], vecArrangement(i.u1), - uint32(i.u2), uint32(i.u3), + uint32(i.u2), uint32(i.u2>>32), )) case vecMisc: c.Emit4Bytes(encodeAdvancedSIMDTwoMisc( vecOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], vecArrangement(i.u2), )) case vecLanes: c.Emit4Bytes(encodeVecLanes( vecOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], vecArrangement(i.u2), )) case vecShiftImm: c.Emit4Bytes(encodeVecShiftImm( vecOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], uint32(i.rm.shiftImm()), vecArrangement(i.u2), @@ -332,7 +332,7 @@ func (i *instruction) encode(m *machine) { case vecTbl: c.Emit4Bytes(encodeVecTbl( 1, - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], vecArrangement(i.u2)), @@ -340,7 +340,7 @@ func (i *instruction) encode(m *machine) { case vecTbl2: c.Emit4Bytes(encodeVecTbl( 2, - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], vecArrangement(i.u2)), @@ -353,9 +353,9 @@ func (i *instruction) encode(m *machine) { case fpuRR: c.Emit4Bytes(encodeFloatDataOneSource( fpuUniOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], - i.u3 == 1, + i.u2 == 1, )) case vecRRR: if op := vecOp(i.u1); op == vecOpBsl || op == vecOpBit || op == vecOpUmlal { @@ -365,14 +365,14 @@ func (i *instruction) encode(m *machine) { case vecRRRRewrite: c.Emit4Bytes(encodeVecRRR( vecOp(i.u1), - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], regNumberInEncoding[i.rm.realReg()], vecArrangement(i.u2), )) case cCmpImm: // Conditional compare (immediate) in https://developer.arm.com/documentation/ddi0596/2020-12/Index-by-Encoding/Data-Processing----Register?lang=en - sf := uint32(i.u3 & 0b1) + sf := uint32((i.u2 >> 32) & 0b1) nzcv := uint32(i.u2 & 0b1111) cond := uint32(condFlag(i.u1)) imm := uint32(i.rm.data & 0b11111) @@ -381,7 +381,7 @@ func (i *instruction) encode(m *machine) { sf<<31 | 0b111101001<<22 | imm<<16 | cond<<12 | 0b1<<11 | rn<<5 | nzcv, ) case movFromFPSR: - rt := regNumberInEncoding[i.rd.realReg()] + rt := regNumberInEncoding[i.rd.RealReg()] c.Emit4Bytes(encodeSystemRegisterMove(rt, true)) case movToFPSR: rt := regNumberInEncoding[i.rn.realReg()] @@ -390,13 +390,13 @@ func (i *instruction) encode(m *machine) { c.Emit4Bytes(encodeAtomicRmw( atomicRmwOp(i.u1), regNumberInEncoding[i.rm.realReg()], - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rn.realReg()], uint32(i.u2), )) case atomicCas: c.Emit4Bytes(encodeAtomicCas( - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], regNumberInEncoding[i.rm.realReg()], regNumberInEncoding[i.rn.realReg()], uint32(i.u2), @@ -404,7 +404,7 @@ func (i *instruction) encode(m *machine) { case atomicLoad: c.Emit4Bytes(encodeAtomicLoadStore( regNumberInEncoding[i.rn.realReg()], - regNumberInEncoding[i.rd.realReg()], + regNumberInEncoding[i.rd.RealReg()], uint32(i.u2), 1, )) @@ -810,7 +810,7 @@ func encodeFloatDataOneSource(op fpuUniOp, rd, rn uint32, dst64bit bool) uint32 // encodeCnvBetweenFloatInt encodes as "Conversion between floating-point and integer" in // https://developer.arm.com/documentation/ddi0596/2020-12/Index-by-Encoding/Data-Processing----Scalar-Floating-Point-and-Advanced-SIMD?lang=en func encodeCnvBetweenFloatInt(i *instruction) uint32 { - rd := regNumberInEncoding[i.rd.realReg()] + rd := regNumberInEncoding[i.rd.RealReg()] rn := regNumberInEncoding[i.rn.realReg()] var opcode uint32 @@ -822,8 +822,8 @@ func encodeCnvBetweenFloatInt(i *instruction) uint32 { rmode = 0b00 signed := i.u1 == 1 - src64bit := i.u2 == 1 - dst64bit := i.u3 == 1 + src64bit := i.u2&1 != 0 + dst64bit := i.u2&2 != 0 if signed { opcode = 0b010 } else { @@ -841,8 +841,8 @@ func encodeCnvBetweenFloatInt(i *instruction) uint32 { rmode = 0b11 signed := i.u1 == 1 - src64bit := i.u2 == 1 - dst64bit := i.u3 == 1 + src64bit := i.u2&1 != 0 + dst64bit := i.u2&2 != 0 if signed { opcode = 0b000 @@ -1787,13 +1787,13 @@ func encodeCBZCBNZ(rt uint32, nz bool, imm19 uint32, _64bit bool) (ret uint32) { // https://developer.arm.com/documentation/ddi0596/2020-12/Index-by-Encoding/Data-Processing----Immediate?lang=en // // "shift" must have been divided by 16 at this point. -func encodeMoveWideImmediate(opc uint32, rd uint32, imm, shift, _64bit uint64) (ret uint32) { +func encodeMoveWideImmediate(opc uint32, rd uint32, imm uint64, shift, _64bit uint32) (ret uint32) { ret = rd ret |= uint32(imm&0xffff) << 5 - ret |= (uint32(shift)) << 21 + ret |= (shift) << 21 ret |= 0b100101 << 23 ret |= opc << 29 - ret |= uint32(_64bit) << 31 + ret |= _64bit << 31 return } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_constant.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_constant.go index 698b382d46..6c6824fb0a 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_constant.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_constant.go @@ -284,18 +284,18 @@ func (m *machine) load64bitConst(c int64, dst regalloc.VReg) { func (m *machine) insertMOVZ(dst regalloc.VReg, v uint64, shift int, dst64 bool) { instr := m.allocateInstr() - instr.asMOVZ(dst, v, uint64(shift), dst64) + instr.asMOVZ(dst, v, uint32(shift), dst64) m.insert(instr) } func (m *machine) insertMOVK(dst regalloc.VReg, v uint64, shift int, dst64 bool) { instr := m.allocateInstr() - instr.asMOVK(dst, v, uint64(shift), dst64) + instr.asMOVK(dst, v, uint32(shift), dst64) m.insert(instr) } func (m *machine) insertMOVN(dst regalloc.VReg, v uint64, shift int, dst64 bool) { instr := m.allocateInstr() - instr.asMOVN(dst, v, uint64(shift), dst64) + instr.asMOVN(dst, v, uint32(shift), dst64) m.insert(instr) } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_instr.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_instr.go index 2bb234e8c1..048bf32040 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_instr.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_instr.go @@ -52,11 +52,11 @@ func (m *machine) lowerBrTable(i *ssa.Instruction) { maxIndexReg := m.compiler.AllocateVReg(ssa.TypeI32) m.lowerConstantI32(maxIndexReg, int32(len(targets)-1)) subs := m.allocateInstr() - subs.asALU(aluOpSubS, operandNR(xzrVReg), indexOperand, operandNR(maxIndexReg), false) + subs.asALU(aluOpSubS, xzrVReg, indexOperand, operandNR(maxIndexReg), false) m.insert(subs) csel := m.allocateInstr() adjustedIndex := m.compiler.AllocateVReg(ssa.TypeI32) - csel.asCSel(operandNR(adjustedIndex), operandNR(maxIndexReg), indexOperand, hs, false) + csel.asCSel(adjustedIndex, operandNR(maxIndexReg), indexOperand, hs, false) m.insert(csel) brSequence := m.allocateInstr() @@ -249,7 +249,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { rc := m.getOperand_NR(m.compiler.ValueDefinition(c), extModeNone) rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) m.lowerSelectVec(rc, rn, rm, rd) } else { m.lowerSelect(c, x, y, instr.Return()) @@ -270,7 +270,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { x, ctx := instr.Arg2() result := instr.Return() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(result)) + rd := m.compiler.VRegOf(result) ctxVReg := m.compiler.VRegOf(ctx) m.lowerFpuToInt(rd, rn, ctxVReg, true, x.Type() == ssa.TypeF64, result.Type().Bits() == 64, op == ssa.OpcodeFcvtToSintSat) @@ -278,7 +278,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { x, ctx := instr.Arg2() result := instr.Return() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(result)) + rd := m.compiler.VRegOf(result) ctxVReg := m.compiler.VRegOf(ctx) m.lowerFpuToInt(rd, rn, ctxVReg, false, x.Type() == ssa.TypeF64, result.Type().Bits() == 64, op == ssa.OpcodeFcvtToUintSat) @@ -286,25 +286,25 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { x := instr.Arg() result := instr.Return() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(result)) + rd := m.compiler.VRegOf(result) m.lowerIntToFpu(rd, rn, true, x.Type() == ssa.TypeI64, result.Type().Bits() == 64) case ssa.OpcodeFcvtFromUint: x := instr.Arg() result := instr.Return() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(result)) + rd := m.compiler.VRegOf(result) m.lowerIntToFpu(rd, rn, false, x.Type() == ssa.TypeI64, result.Type().Bits() == 64) case ssa.OpcodeFdemote: v := instr.Arg() rn := m.getOperand_NR(m.compiler.ValueDefinition(v), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) cnt := m.allocateInstr() cnt.asFpuRR(fpuUniOpCvt64To32, rd, rn, false) m.insert(cnt) case ssa.OpcodeFpromote: v := instr.Arg() rn := m.getOperand_NR(m.compiler.ValueDefinition(v), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) cnt := m.allocateInstr() cnt.asFpuRR(fpuUniOpCvt32To64, rd, rn, true) m.insert(cnt) @@ -343,15 +343,15 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { ctxVReg := m.compiler.VRegOf(ctx) rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) m.lowerIDiv(ctxVReg, rd, rn, rm, x.Type() == ssa.TypeI64, op == ssa.OpcodeSdiv) case ssa.OpcodeSrem, ssa.OpcodeUrem: x, y, ctx := instr.Arg3() ctxVReg := m.compiler.VRegOf(ctx) rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) - m.lowerIRem(ctxVReg, rd, rn, rm, x.Type() == ssa.TypeI64, op == ssa.OpcodeSrem) + rd := m.compiler.VRegOf(instr.Return()) + m.lowerIRem(ctxVReg, rd, rn.nr(), rm, x.Type() == ssa.TypeI64, op == ssa.OpcodeSrem) case ssa.OpcodeVconst: result := m.compiler.VRegOf(instr.Return()) lo, hi := instr.VconstData() @@ -362,7 +362,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { x := instr.Arg() ins := m.allocateInstr() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) ins.asVecMisc(vecOpNot, rd, rn, vecArrangement16B) m.insert(ins) case ssa.OpcodeVbxor: @@ -382,12 +382,12 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) creg := m.getOperand_NR(m.compiler.ValueDefinition(c), extModeNone) - tmp := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) + tmp := m.compiler.AllocateVReg(ssa.TypeV128) // creg is overwritten by BSL, so we need to move it to the result register before the instruction // in case when it is used somewhere else. mov := m.allocateInstr() - mov.asFpuMov128(tmp.nr(), creg.nr()) + mov.asFpuMov128(tmp, creg.nr()) m.insert(mov) ins := m.allocateInstr() @@ -396,7 +396,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { mov2 := m.allocateInstr() rd := m.compiler.VRegOf(instr.Return()) - mov2.asFpuMov128(rd, tmp.nr()) + mov2.asFpuMov128(rd, tmp) m.insert(mov2) case ssa.OpcodeVanyTrue, ssa.OpcodeVallTrue: x, lane := instr.ArgWithLane() @@ -405,12 +405,12 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { arr = ssaLaneToArrangement(lane) } rm := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) m.lowerVcheckTrue(op, rm, rd, arr) case ssa.OpcodeVhighBits: x, lane := instr.ArgWithLane() rm := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) arr := ssaLaneToArrangement(lane) m.lowerVhighBits(rm, rd, arr) case ssa.OpcodeVIadd: @@ -441,9 +441,9 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { panic("unsupported lane " + lane.String()) } - widenLo := m.allocateInstr().asVecShiftImm(widen, tmpLo, vv, operandShiftImm(0), loArr) - widenHi := m.allocateInstr().asVecShiftImm(widen, tmpHi, vv, operandShiftImm(0), hiArr) - addp := m.allocateInstr().asVecRRR(vecOpAddp, operandNR(m.compiler.VRegOf(instr.Return())), tmpLo, tmpHi, dstArr) + widenLo := m.allocateInstr().asVecShiftImm(widen, tmpLo.nr(), vv, operandShiftImm(0), loArr) + widenHi := m.allocateInstr().asVecShiftImm(widen, tmpHi.nr(), vv, operandShiftImm(0), hiArr) + addp := m.allocateInstr().asVecRRR(vecOpAddp, m.compiler.VRegOf(instr.Return()), tmpLo, tmpHi, dstArr) m.insert(widenLo) m.insert(widenHi) m.insert(addp) @@ -493,7 +493,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { arr := ssaLaneToArrangement(lane) rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) m.lowerVIMul(rd, rn, rm, arr) case ssa.OpcodeVIabs: m.lowerVecMisc(vecOpAbs, instr) @@ -507,7 +507,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { arr := ssaLaneToArrangement(lane) rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) m.lowerVShift(op, rd, rn, rm, arr) case ssa.OpcodeVSqrt: m.lowerVecMisc(vecOpFsqrt, instr) @@ -547,18 +547,18 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { x, lane := instr.ArgWithLane() arr := ssaLaneToArrangement(lane) rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) m.lowerVfpuToInt(rd, rn, arr, op == ssa.OpcodeVFcvtToSintSat) case ssa.OpcodeVFcvtFromSint, ssa.OpcodeVFcvtFromUint: x, lane := instr.ArgWithLane() arr := ssaLaneToArrangement(lane) rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) m.lowerVfpuFromInt(rd, rn, arr, op == ssa.OpcodeVFcvtFromSint) case ssa.OpcodeSwidenLow, ssa.OpcodeUwidenLow: x, lane := instr.ArgWithLane() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) var arr vecArrangement switch lane { @@ -580,7 +580,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { case ssa.OpcodeSwidenHigh, ssa.OpcodeUwidenHigh: x, lane := instr.ArgWithLane() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) arr := ssaLaneToArrangement(lane) @@ -607,9 +607,9 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { } rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) - tmp := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) + tmp := m.compiler.AllocateVReg(ssa.TypeV128) loQxtn := m.allocateInstr() hiQxtn := m.allocateInstr() @@ -628,7 +628,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { m.insert(hiQxtn) mov := m.allocateInstr() - mov.asFpuMov128(rd.nr(), tmp.nr()) + mov.asFpuMov128(rd, tmp) m.insert(mov) case ssa.OpcodeFvpromoteLow: x, lane := instr.ArgWithLane() @@ -637,7 +637,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { } ins := m.allocateInstr() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) ins.asVecMisc(vecOpFcvtl, rd, rn, vecArrangement2S) m.insert(ins) case ssa.OpcodeFvdemote: @@ -647,14 +647,14 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { } ins := m.allocateInstr() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) ins.asVecMisc(vecOpFcvtn, rd, rn, vecArrangement2S) m.insert(ins) case ssa.OpcodeExtractlane: x, index, signed, lane := instr.ExtractlaneData() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) mov := m.allocateInstr() switch lane { @@ -680,12 +680,12 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { x, y, index, lane := instr.InsertlaneData() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) - tmpReg := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) + rd := m.compiler.VRegOf(instr.Return()) + tmpReg := m.compiler.AllocateVReg(ssa.TypeV128) // Initially mov rn to tmp. mov1 := m.allocateInstr() - mov1.asFpuMov128(tmpReg.nr(), rn.nr()) + mov1.asFpuMov128(tmpReg, rn.nr()) m.insert(mov1) // movToVec and vecMovElement do not clear the remaining bits to zero, @@ -709,14 +709,14 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { // Finally mov tmp to rd. mov3 := m.allocateInstr() - mov3.asFpuMov128(rd.nr(), tmpReg.nr()) + mov3.asFpuMov128(rd, tmpReg) m.insert(mov3) case ssa.OpcodeSwizzle: x, y, lane := instr.Arg2WithLane() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) arr := ssaLaneToArrangement(lane) @@ -729,14 +729,14 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { x, y, lane1, lane2 := instr.ShuffleData() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) m.lowerShuffle(rd, rn, rm, lane1, lane2) case ssa.OpcodeSplat: x, lane := instr.ArgWithLane() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) dup := m.allocateInstr() switch lane { @@ -760,12 +760,12 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { xx, yy := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone), m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) tmp, tmp2 := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)), operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) - m.insert(m.allocateInstr().asVecRRR(vecOpSmull, tmp, xx, yy, vecArrangement8H)) - m.insert(m.allocateInstr().asVecRRR(vecOpSmull2, tmp2, xx, yy, vecArrangement8H)) - m.insert(m.allocateInstr().asVecRRR(vecOpAddp, tmp, tmp, tmp2, vecArrangement4S)) + m.insert(m.allocateInstr().asVecRRR(vecOpSmull, tmp.nr(), xx, yy, vecArrangement8H)) + m.insert(m.allocateInstr().asVecRRR(vecOpSmull2, tmp2.nr(), xx, yy, vecArrangement8H)) + m.insert(m.allocateInstr().asVecRRR(vecOpAddp, tmp.nr(), tmp, tmp2, vecArrangement4S)) - rd := operandNR(m.compiler.VRegOf(instr.Return())) - m.insert(m.allocateInstr().asFpuMov128(rd.nr(), tmp.nr())) + rd := m.compiler.VRegOf(instr.Return()) + m.insert(m.allocateInstr().asFpuMov128(rd, tmp.nr())) case ssa.OpcodeLoadSplat: ptr, offset, lane := instr.LoadSplatData() @@ -794,7 +794,7 @@ func (m *machine) LowerInstr(instr *ssa.Instruction) { m.executableContext.FlushPendingInstructions() } -func (m *machine) lowerShuffle(rd, rn, rm operand, lane1, lane2 uint64) { +func (m *machine) lowerShuffle(rd regalloc.VReg, rn, rm operand, lane1, lane2 uint64) { // `tbl2` requires 2 consecutive registers, so we arbitrarily pick v29, v30. vReg, wReg := v29VReg, v30VReg @@ -822,7 +822,7 @@ func (m *machine) lowerShuffle(rd, rn, rm operand, lane1, lane2 uint64) { m.insert(tbl2) } -func (m *machine) lowerVShift(op ssa.Opcode, rd, rn, rm operand, arr vecArrangement) { +func (m *machine) lowerVShift(op ssa.Opcode, rd regalloc.VReg, rn, rm operand, arr vecArrangement) { var modulo byte switch arr { case vecArrangement16B: @@ -847,13 +847,13 @@ func (m *machine) lowerVShift(op ssa.Opcode, rd, rn, rm operand, arr vecArrangem if op != ssa.OpcodeVIshl { // Negate the amount to make this as right shift. neg := m.allocateInstr() - neg.asALU(aluOpSub, rtmp, operandNR(xzrVReg), rtmp, true) + neg.asALU(aluOpSub, rtmp.nr(), operandNR(xzrVReg), rtmp, true) m.insert(neg) } // Copy the shift amount into a vector register as sshl/ushl requires it to be there. dup := m.allocateInstr() - dup.asVecDup(vtmp, rtmp, arr) + dup.asVecDup(vtmp.nr(), rtmp, arr) m.insert(dup) if op == ssa.OpcodeVIshl || op == ssa.OpcodeVSshr { @@ -867,7 +867,7 @@ func (m *machine) lowerVShift(op ssa.Opcode, rd, rn, rm operand, arr vecArrangem } } -func (m *machine) lowerVcheckTrue(op ssa.Opcode, rm, rd operand, arr vecArrangement) { +func (m *machine) lowerVcheckTrue(op ssa.Opcode, rm operand, rd regalloc.VReg, arr vecArrangement) { tmp := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) // Special case VallTrue for i64x2. @@ -878,11 +878,11 @@ func (m *machine) lowerVcheckTrue(op ssa.Opcode, rm, rd operand, arr vecArrangem // cset dst, eq ins := m.allocateInstr() - ins.asVecMisc(vecOpCmeq0, tmp, rm, vecArrangement2D) + ins.asVecMisc(vecOpCmeq0, tmp.nr(), rm, vecArrangement2D) m.insert(ins) addp := m.allocateInstr() - addp.asVecRRR(vecOpAddp, tmp, tmp, tmp, vecArrangement2D) + addp.asVecRRR(vecOpAddp, tmp.nr(), tmp, tmp, vecArrangement2D) m.insert(addp) fcmp := m.allocateInstr() @@ -890,7 +890,7 @@ func (m *machine) lowerVcheckTrue(op ssa.Opcode, rm, rd operand, arr vecArrangem m.insert(fcmp) cset := m.allocateInstr() - cset.asCSet(rd.nr(), false, eq) + cset.asCSet(rd, false, eq) m.insert(cset) return @@ -900,10 +900,10 @@ func (m *machine) lowerVcheckTrue(op ssa.Opcode, rm, rd operand, arr vecArrangem ins := m.allocateInstr() if op == ssa.OpcodeVanyTrue { // umaxp v4?.16b, v2?.16b, v2?.16b - ins.asVecRRR(vecOpUmaxp, tmp, rm, rm, vecArrangement16B) + ins.asVecRRR(vecOpUmaxp, tmp.nr(), rm, rm, vecArrangement16B) } else { // uminv d4?, v2?.4s - ins.asVecLanes(vecOpUminv, tmp, rm, arr) + ins.asVecLanes(vecOpUminv, tmp.nr(), rm, arr) } m.insert(ins) @@ -917,15 +917,15 @@ func (m *machine) lowerVcheckTrue(op ssa.Opcode, rm, rd operand, arr vecArrangem m.insert(movv) fc := m.allocateInstr() - fc.asCCmpImm(rd, uint64(0), al, 0, true) + fc.asCCmpImm(operandNR(rd), uint64(0), al, 0, true) m.insert(fc) cset := m.allocateInstr() - cset.asCSet(rd.nr(), false, ne) + cset.asCSet(rd, false, ne) m.insert(cset) } -func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { +func (m *machine) lowerVhighBits(rm operand, rd regalloc.VReg, arr vecArrangement) { r0 := operandNR(m.compiler.AllocateVReg(ssa.TypeI64)) v0 := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) v1 := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) @@ -947,7 +947,7 @@ func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { // Right arithmetic shift on the original vector and store the result into v1. So we have: // v1[i] = 0xff if vi<0, 0 otherwise. sshr := m.allocateInstr() - sshr.asVecShiftImm(vecOpSshr, v1, rm, operandShiftImm(7), vecArrangement16B) + sshr.asVecShiftImm(vecOpSshr, v1.nr(), rm, operandShiftImm(7), vecArrangement16B) m.insert(sshr) // Load the bit mask into r0. @@ -958,7 +958,7 @@ func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { // dup r0 to v0. dup := m.allocateInstr() - dup.asVecDup(v0, r0, vecArrangement2D) + dup.asVecDup(v0.nr(), r0, vecArrangement2D) m.insert(dup) // Lane-wise logical AND with the bit mask, meaning that we have @@ -967,23 +967,23 @@ func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { // Below, we use the following notation: // wi := (1 << i) if vi<0, 0 otherwise. and := m.allocateInstr() - and.asVecRRR(vecOpAnd, v1, v1, v0, vecArrangement16B) + and.asVecRRR(vecOpAnd, v1.nr(), v1, v0, vecArrangement16B) m.insert(and) // Swap the lower and higher 8 byte elements, and write it into v0, meaning that we have // v0[i] = w(i+8) if i < 8, w(i-8) otherwise. ext := m.allocateInstr() - ext.asVecExtract(v0, v1, v1, vecArrangement16B, uint32(8)) + ext.asVecExtract(v0.nr(), v1, v1, vecArrangement16B, uint32(8)) m.insert(ext) // v = [w0, w8, ..., w7, w15] zip1 := m.allocateInstr() - zip1.asVecPermute(vecOpZip1, v0, v1, v0, vecArrangement16B) + zip1.asVecPermute(vecOpZip1, v0.nr(), v1, v0, vecArrangement16B) m.insert(zip1) // v.h[0] = w0 + ... + w15 addv := m.allocateInstr() - addv.asVecLanes(vecOpAddv, v0, v0, vecArrangement8H) + addv.asVecLanes(vecOpAddv, v0.nr(), v0, vecArrangement8H) m.insert(addv) // Extract the v.h[0] as the result. @@ -1006,7 +1006,7 @@ func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { // Right arithmetic shift on the original vector and store the result into v1. So we have: // v[i] = 0xffff if vi<0, 0 otherwise. sshr := m.allocateInstr() - sshr.asVecShiftImm(vecOpSshr, v1, rm, operandShiftImm(15), vecArrangement8H) + sshr.asVecShiftImm(vecOpSshr, v1.nr(), rm, operandShiftImm(15), vecArrangement8H) m.insert(sshr) // Load the bit mask into r0. @@ -1014,26 +1014,26 @@ func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { // dup r0 to vector v0. dup := m.allocateInstr() - dup.asVecDup(v0, r0, vecArrangement2D) + dup.asVecDup(v0.nr(), r0, vecArrangement2D) m.insert(dup) lsl := m.allocateInstr() - lsl.asALUShift(aluOpLsl, r0, r0, operandShiftImm(4), true) + lsl.asALUShift(aluOpLsl, r0.nr(), r0, operandShiftImm(4), true) m.insert(lsl) movv := m.allocateInstr() - movv.asMovToVec(v0, r0, vecArrangementD, vecIndex(1)) + movv.asMovToVec(v0.nr(), r0, vecArrangementD, vecIndex(1)) m.insert(movv) // Lane-wise logical AND with the bitmask, meaning that we have // v[i] = (1 << i) if vi<0, 0 otherwise for i=0..3 // = (1 << (i+4)) if vi<0, 0 otherwise for i=3..7 and := m.allocateInstr() - and.asVecRRR(vecOpAnd, v0, v1, v0, vecArrangement16B) + and.asVecRRR(vecOpAnd, v0.nr(), v1, v0, vecArrangement16B) m.insert(and) addv := m.allocateInstr() - addv.asVecLanes(vecOpAddv, v0, v0, vecArrangement8H) + addv.asVecLanes(vecOpAddv, v0.nr(), v0, vecArrangement8H) m.insert(addv) movfv := m.allocateInstr() @@ -1055,7 +1055,7 @@ func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { // Right arithmetic shift on the original vector and store the result into v1. So we have: // v[i] = 0xffffffff if vi<0, 0 otherwise. sshr := m.allocateInstr() - sshr.asVecShiftImm(vecOpSshr, v1, rm, operandShiftImm(31), vecArrangement4S) + sshr.asVecShiftImm(vecOpSshr, v1.nr(), rm, operandShiftImm(31), vecArrangement4S) m.insert(sshr) // Load the bit mask into r0. @@ -1063,26 +1063,26 @@ func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { // dup r0 to vector v0. dup := m.allocateInstr() - dup.asVecDup(v0, r0, vecArrangement2D) + dup.asVecDup(v0.nr(), r0, vecArrangement2D) m.insert(dup) lsl := m.allocateInstr() - lsl.asALUShift(aluOpLsl, r0, r0, operandShiftImm(2), true) + lsl.asALUShift(aluOpLsl, r0.nr(), r0, operandShiftImm(2), true) m.insert(lsl) movv := m.allocateInstr() - movv.asMovToVec(v0, r0, vecArrangementD, vecIndex(1)) + movv.asMovToVec(v0.nr(), r0, vecArrangementD, vecIndex(1)) m.insert(movv) // Lane-wise logical AND with the bitmask, meaning that we have // v[i] = (1 << i) if vi<0, 0 otherwise for i in [0, 1] // = (1 << (i+4)) if vi<0, 0 otherwise for i in [2, 3] and := m.allocateInstr() - and.asVecRRR(vecOpAnd, v0, v1, v0, vecArrangement16B) + and.asVecRRR(vecOpAnd, v0.nr(), v1, v0, vecArrangement16B) m.insert(and) addv := m.allocateInstr() - addv.asVecLanes(vecOpAddv, v0, v0, vecArrangement4S) + addv.asVecLanes(vecOpAddv, v0.nr(), v0, vecArrangement4S) m.insert(addv) movfv := m.allocateInstr() @@ -1102,21 +1102,21 @@ func (m *machine) lowerVhighBits(rm, rd operand, arr vecArrangement) { // Move the higher 64-bit int into r0. movv1 := m.allocateInstr() - movv1.asMovFromVec(r0, rm, vecArrangementD, vecIndex(1), false) + movv1.asMovFromVec(r0.nr(), rm, vecArrangementD, vecIndex(1), false) m.insert(movv1) // Move the sign bit into the least significant bit. lsr1 := m.allocateInstr() - lsr1.asALUShift(aluOpLsr, r0, r0, operandShiftImm(63), true) + lsr1.asALUShift(aluOpLsr, r0.nr(), r0, operandShiftImm(63), true) m.insert(lsr1) lsr2 := m.allocateInstr() - lsr2.asALUShift(aluOpLsr, rd, rd, operandShiftImm(63), true) + lsr2.asALUShift(aluOpLsr, rd, operandNR(rd), operandShiftImm(63), true) m.insert(lsr2) // rd = (r0<<1) | rd lsl := m.allocateInstr() - lsl.asALU(aluOpAdd, rd, rd, operandSR(r0.nr(), 1, shiftOpLSL), false) + lsl.asALU(aluOpAdd, rd, operandNR(rd), operandSR(r0.nr(), 1, shiftOpLSL), false) m.insert(lsl) default: panic("Unsupported " + arr.String()) @@ -1128,7 +1128,7 @@ func (m *machine) lowerVecMisc(op vecOp, instr *ssa.Instruction) { arr := ssaLaneToArrangement(lane) ins := m.allocateInstr() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) ins.asVecMisc(op, rd, rn, arr) m.insert(ins) } @@ -1137,22 +1137,22 @@ func (m *machine) lowerVecRRR(op vecOp, x, y, ret ssa.Value, arr vecArrangement) ins := m.allocateInstr() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(ret)) + rd := m.compiler.VRegOf(ret) ins.asVecRRR(op, rd, rn, rm, arr) m.insert(ins) } -func (m *machine) lowerVIMul(rd, rn, rm operand, arr vecArrangement) { +func (m *machine) lowerVIMul(rd regalloc.VReg, rn, rm operand, arr vecArrangement) { if arr != vecArrangement2D { mul := m.allocateInstr() mul.asVecRRR(vecOpMul, rd, rn, rm, arr) m.insert(mul) } else { - tmp1 := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) - tmp2 := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) - tmp3 := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) + tmp1 := m.compiler.AllocateVReg(ssa.TypeV128) + tmp2 := m.compiler.AllocateVReg(ssa.TypeV128) + tmp3 := m.compiler.AllocateVReg(ssa.TypeV128) - tmpRes := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) + tmpRes := m.compiler.AllocateVReg(ssa.TypeV128) // Following the algorithm in https://chromium-review.googlesource.com/c/v8/v8/+/1781696 rev64 := m.allocateInstr() @@ -1160,7 +1160,7 @@ func (m *machine) lowerVIMul(rd, rn, rm operand, arr vecArrangement) { m.insert(rev64) mul := m.allocateInstr() - mul.asVecRRR(vecOpMul, tmp2, tmp2, rn, vecArrangement4S) + mul.asVecRRR(vecOpMul, tmp2, operandNR(tmp2), rn, vecArrangement4S) m.insert(mul) xtn1 := m.allocateInstr() @@ -1168,7 +1168,7 @@ func (m *machine) lowerVIMul(rd, rn, rm operand, arr vecArrangement) { m.insert(xtn1) addp := m.allocateInstr() - addp.asVecRRR(vecOpAddp, tmp2, tmp2, tmp2, vecArrangement4S) + addp.asVecRRR(vecOpAddp, tmp2, operandNR(tmp2), operandNR(tmp2), vecArrangement4S) m.insert(addp) xtn2 := m.allocateInstr() @@ -1179,15 +1179,15 @@ func (m *machine) lowerVIMul(rd, rn, rm operand, arr vecArrangement) { // In short, in UMLAL instruction, the result register is also one of the source register, and // the value on the result register is significant. shll := m.allocateInstr() - shll.asVecMisc(vecOpShll, tmpRes, tmp2, vecArrangement2S) + shll.asVecMisc(vecOpShll, tmpRes, operandNR(tmp2), vecArrangement2S) m.insert(shll) umlal := m.allocateInstr() - umlal.asVecRRRRewrite(vecOpUmlal, tmpRes, tmp3, tmp1, vecArrangement2S) + umlal.asVecRRRRewrite(vecOpUmlal, tmpRes, operandNR(tmp3), operandNR(tmp1), vecArrangement2S) m.insert(umlal) mov := m.allocateInstr() - mov.asFpuMov128(rd.nr(), tmpRes.nr()) + mov.asFpuMov128(rd, tmpRes) m.insert(mov) } } @@ -1203,7 +1203,7 @@ func (m *machine) lowerVMinMaxPseudo(instr *ssa.Instruction, max bool) { // BSL modifies the destination register, so we need to use a temporary register so that // the actual definition of the destination register happens *after* the BSL instruction. // That way, we can force the spill instruction to be inserted after the BSL instruction. - tmp := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) + tmp := m.compiler.AllocateVReg(ssa.TypeV128) fcmgt := m.allocateInstr() if max { @@ -1220,17 +1220,17 @@ func (m *machine) lowerVMinMaxPseudo(instr *ssa.Instruction, max bool) { res := operandNR(m.compiler.VRegOf(instr.Return())) mov2 := m.allocateInstr() - mov2.asFpuMov128(res.nr(), tmp.nr()) + mov2.asFpuMov128(res.nr(), tmp) m.insert(mov2) } -func (m *machine) lowerIRem(execCtxVReg regalloc.VReg, rd, rn, rm operand, _64bit, signed bool) { +func (m *machine) lowerIRem(execCtxVReg regalloc.VReg, rd, rn regalloc.VReg, rm operand, _64bit, signed bool) { div := m.allocateInstr() if signed { - div.asALU(aluOpSDiv, rd, rn, rm, _64bit) + div.asALU(aluOpSDiv, rd, operandNR(rn), rm, _64bit) } else { - div.asALU(aluOpUDiv, rd, rn, rm, _64bit) + div.asALU(aluOpUDiv, rd, operandNR(rn), rm, _64bit) } m.insert(div) @@ -1239,11 +1239,11 @@ func (m *machine) lowerIRem(execCtxVReg regalloc.VReg, rd, rn, rm operand, _64bi // rd = rn-rd*rm by MSUB instruction. msub := m.allocateInstr() - msub.asALURRRR(aluOpMSub, rd, rd, rm, rn, _64bit) + msub.asALURRRR(aluOpMSub, rd, operandNR(rd), rm, rn, _64bit) m.insert(msub) } -func (m *machine) lowerIDiv(execCtxVReg regalloc.VReg, rd, rn, rm operand, _64bit, signed bool) { +func (m *machine) lowerIDiv(execCtxVReg, rd regalloc.VReg, rn, rm operand, _64bit, signed bool) { div := m.allocateInstr() if signed { @@ -1260,7 +1260,7 @@ func (m *machine) lowerIDiv(execCtxVReg regalloc.VReg, rd, rn, rm operand, _64bi // We need to check the signed overflow which happens iff "math.MinInt{32,64} / -1" minusOneCheck := m.allocateInstr() // Sets eq condition if rm == -1. - minusOneCheck.asALU(aluOpAddS, operandNR(xzrVReg), rm, operandImm12(1, 0), _64bit) + minusOneCheck.asALU(aluOpAddS, xzrVReg, rm, operandImm12(1, 0), _64bit) m.insert(minusOneCheck) ccmp := m.allocateInstr() @@ -1290,20 +1290,20 @@ func (m *machine) exitIfNot(execCtxVReg regalloc.VReg, c cond, cond64bit bool, c func (m *machine) lowerFcopysign(x, y, ret ssa.Value) { rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - var tmpI, tmpF operand + var tmpI, tmpF regalloc.VReg _64 := x.Type() == ssa.TypeF64 if _64 { - tmpF = operandNR(m.compiler.AllocateVReg(ssa.TypeF64)) - tmpI = operandNR(m.compiler.AllocateVReg(ssa.TypeI64)) + tmpF = m.compiler.AllocateVReg(ssa.TypeF64) + tmpI = m.compiler.AllocateVReg(ssa.TypeI64) } else { - tmpF = operandNR(m.compiler.AllocateVReg(ssa.TypeF32)) - tmpI = operandNR(m.compiler.AllocateVReg(ssa.TypeI32)) + tmpF = m.compiler.AllocateVReg(ssa.TypeF32) + tmpI = m.compiler.AllocateVReg(ssa.TypeI32) } rd := m.compiler.VRegOf(ret) - m.lowerFcopysignImpl(operandNR(rd), rn, rm, tmpI, tmpF, _64) + m.lowerFcopysignImpl(rd, rn, rm, tmpI, tmpF, _64) } -func (m *machine) lowerFcopysignImpl(rd, rn, rm, tmpI, tmpF operand, _64bit bool) { +func (m *machine) lowerFcopysignImpl(rd regalloc.VReg, rn, rm operand, tmpI, tmpF regalloc.VReg, _64bit bool) { // This is exactly the same code emitted by GCC for "__builtin_copysign": // // mov x0, -9223372036854775808 @@ -1313,26 +1313,26 @@ func (m *machine) lowerFcopysignImpl(rd, rn, rm, tmpI, tmpF operand, _64bit bool setMSB := m.allocateInstr() if _64bit { - m.lowerConstantI64(tmpI.nr(), math.MinInt64) - setMSB.asMovToVec(tmpF, tmpI, vecArrangementD, vecIndex(0)) + m.lowerConstantI64(tmpI, math.MinInt64) + setMSB.asMovToVec(tmpF, operandNR(tmpI), vecArrangementD, vecIndex(0)) } else { - m.lowerConstantI32(tmpI.nr(), math.MinInt32) - setMSB.asMovToVec(tmpF, tmpI, vecArrangementS, vecIndex(0)) + m.lowerConstantI32(tmpI, math.MinInt32) + setMSB.asMovToVec(tmpF, operandNR(tmpI), vecArrangementS, vecIndex(0)) } m.insert(setMSB) - tmpReg := operandNR(m.compiler.AllocateVReg(ssa.TypeF64)) + tmpReg := m.compiler.AllocateVReg(ssa.TypeF64) mov := m.allocateInstr() - mov.asFpuMov64(tmpReg.nr(), rn.nr()) + mov.asFpuMov64(tmpReg, rn.nr()) m.insert(mov) vbit := m.allocateInstr() - vbit.asVecRRRRewrite(vecOpBit, tmpReg, rm, tmpF, vecArrangement8B) + vbit.asVecRRRRewrite(vecOpBit, tmpReg, rm, operandNR(tmpF), vecArrangement8B) m.insert(vbit) movDst := m.allocateInstr() - movDst.asFpuMov64(rd.nr(), tmpReg.nr()) + movDst.asFpuMov64(rd, tmpReg) m.insert(movDst) } @@ -1340,7 +1340,7 @@ func (m *machine) lowerBitcast(instr *ssa.Instruction) { v, dstType := instr.BitcastData() srcType := v.Type() rn := m.getOperand_NR(m.compiler.ValueDefinition(v), extModeNone) - rd := operandNR(m.compiler.VRegOf(instr.Return())) + rd := m.compiler.VRegOf(instr.Return()) srcInt := srcType.IsInt() dstInt := dstType.IsInt() switch { @@ -1371,14 +1371,14 @@ func (m *machine) lowerBitcast(instr *ssa.Instruction) { func (m *machine) lowerFpuUniOp(op fpuUniOp, in, out ssa.Value) { rn := m.getOperand_NR(m.compiler.ValueDefinition(in), extModeNone) - rd := operandNR(m.compiler.VRegOf(out)) + rd := m.compiler.VRegOf(out) neg := m.allocateInstr() neg.asFpuRR(op, rd, rn, in.Type().Bits() == 64) m.insert(neg) } -func (m *machine) lowerFpuToInt(rd, rn operand, ctx regalloc.VReg, signed, src64bit, dst64bit, nonTrapping bool) { +func (m *machine) lowerFpuToInt(rd regalloc.VReg, rn operand, ctx regalloc.VReg, signed, src64bit, dst64bit, nonTrapping bool) { if !nonTrapping { // First of all, we have to clear the FPU flags. flagClear := m.allocateInstr() @@ -1405,7 +1405,7 @@ func (m *machine) lowerFpuToInt(rd, rn operand, ctx regalloc.VReg, signed, src64 // Check if the conversion was undefined by comparing the status with 1. // See https://developer.arm.com/documentation/ddi0595/2020-12/AArch64-Registers/FPSR--Floating-point-Status-Register alu := m.allocateInstr() - alu.asALU(aluOpSubS, operandNR(xzrVReg), operandNR(tmpReg), operandImm12(1, 0), true) + alu.asALU(aluOpSubS, xzrVReg, operandNR(tmpReg), operandImm12(1, 0), true) m.insert(alu) // If it is not undefined, we can return the result. @@ -1429,7 +1429,7 @@ func (m *machine) lowerFpuToInt(rd, rn operand, ctx regalloc.VReg, signed, src64 } } -func (m *machine) lowerIntToFpu(rd, rn operand, signed, src64bit, dst64bit bool) { +func (m *machine) lowerIntToFpu(rd regalloc.VReg, rn operand, signed, src64bit, dst64bit bool) { cvt := m.allocateInstr() cvt.asIntToFpu(rd, rn, signed, src64bit, dst64bit) m.insert(cvt) @@ -1456,7 +1456,7 @@ func (m *machine) lowerFpuBinOp(si *ssa.Instruction) { xDef, yDef := m.compiler.ValueDefinition(x), m.compiler.ValueDefinition(y) rn := m.getOperand_NR(xDef, extModeNone) rm := m.getOperand_NR(yDef, extModeNone) - rd := operandNR(m.compiler.VRegOf(si.Return())) + rd := m.compiler.VRegOf(si.Return()) instr.asFpuRRR(op, rd, rn, rm, x.Type().Bits() == 64) m.insert(instr) } @@ -1482,7 +1482,7 @@ func (m *machine) lowerSubOrAdd(si *ssa.Instruction, add bool) { case !add && yNegated: // rn+rm = x-(-y) = x-y aop = aluOpAdd } - rd := operandNR(m.compiler.VRegOf(si.Return())) + rd := m.compiler.VRegOf(si.Return()) alu := m.allocateInstr() alu.asALU(aop, rd, rn, rm, x.Type().Bits() == 64) m.insert(alu) @@ -1527,7 +1527,7 @@ func (m *machine) lowerIcmp(si *ssa.Instruction) { rn := m.getOperand_NR(m.compiler.ValueDefinition(x), ext) rm := m.getOperand_Imm12_ER_SR_NR(m.compiler.ValueDefinition(y), ext) alu := m.allocateInstr() - alu.asALU(aluOpSubS, operandNR(xzrVReg), rn, rm, in64bit) + alu.asALU(aluOpSubS, xzrVReg, rn, rm, in64bit) m.insert(alu) cset := m.allocateInstr() @@ -1542,7 +1542,7 @@ func (m *machine) lowerVIcmp(si *ssa.Instruction) { rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(si.Return())) + rd := m.compiler.VRegOf(si.Return()) switch flag { case eq: @@ -1554,7 +1554,7 @@ func (m *machine) lowerVIcmp(si *ssa.Instruction) { cmp.asVecRRR(vecOpCmeq, rd, rn, rm, arr) m.insert(cmp) not := m.allocateInstr() - not.asVecMisc(vecOpNot, rd, rd, vecArrangement16B) + not.asVecMisc(vecOpNot, rd, operandNR(rd), vecArrangement16B) m.insert(not) case ge: cmp := m.allocateInstr() @@ -1598,7 +1598,7 @@ func (m *machine) lowerVFcmp(si *ssa.Instruction) { rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(si.Return())) + rd := m.compiler.VRegOf(si.Return()) switch flag { case eq: @@ -1610,7 +1610,7 @@ func (m *machine) lowerVFcmp(si *ssa.Instruction) { cmp.asVecRRR(vecOpFcmeq, rd, rn, rm, arr) m.insert(cmp) not := m.allocateInstr() - not.asVecMisc(vecOpNot, rd, rd, vecArrangement16B) + not.asVecMisc(vecOpNot, rd, operandNR(rd), vecArrangement16B) m.insert(not) case ge: cmp := m.allocateInstr() @@ -1631,7 +1631,7 @@ func (m *machine) lowerVFcmp(si *ssa.Instruction) { } } -func (m *machine) lowerVfpuToInt(rd, rn operand, arr vecArrangement, signed bool) { +func (m *machine) lowerVfpuToInt(rd regalloc.VReg, rn operand, arr vecArrangement, signed bool) { cvt := m.allocateInstr() if signed { cvt.asVecMisc(vecOpFcvtzs, rd, rn, arr) @@ -1643,15 +1643,15 @@ func (m *machine) lowerVfpuToInt(rd, rn operand, arr vecArrangement, signed bool if arr == vecArrangement2D { narrow := m.allocateInstr() if signed { - narrow.asVecMisc(vecOpSqxtn, rd, rd, vecArrangement2S) + narrow.asVecMisc(vecOpSqxtn, rd, operandNR(rd), vecArrangement2S) } else { - narrow.asVecMisc(vecOpUqxtn, rd, rd, vecArrangement2S) + narrow.asVecMisc(vecOpUqxtn, rd, operandNR(rd), vecArrangement2S) } m.insert(narrow) } } -func (m *machine) lowerVfpuFromInt(rd, rn operand, arr vecArrangement, signed bool) { +func (m *machine) lowerVfpuFromInt(rd regalloc.VReg, rn operand, arr vecArrangement, signed bool) { cvt := m.allocateInstr() if signed { cvt.asVecMisc(vecOpScvtf, rd, rn, arr) @@ -1665,7 +1665,7 @@ func (m *machine) lowerShifts(si *ssa.Instruction, ext extMode, aluOp aluOp) { x, amount := si.Arg2() rn := m.getOperand_NR(m.compiler.ValueDefinition(x), ext) rm := m.getOperand_ShiftImm_NR(m.compiler.ValueDefinition(amount), ext, x.Type().Bits()) - rd := operandNR(m.compiler.VRegOf(si.Return())) + rd := m.compiler.VRegOf(si.Return()) alu := m.allocateInstr() alu.asALUShift(aluOp, rd, rn, rm, x.Type().Bits() == 64) @@ -1678,11 +1678,11 @@ func (m *machine) lowerBitwiseAluOp(si *ssa.Instruction, op aluOp, ignoreResult xDef, yDef := m.compiler.ValueDefinition(x), m.compiler.ValueDefinition(y) rn := m.getOperand_NR(xDef, extModeNone) - var rd operand + var rd regalloc.VReg if ignoreResult { - rd = operandNR(xzrVReg) + rd = xzrVReg } else { - rd = operandNR(m.compiler.VRegOf(si.Return())) + rd = m.compiler.VRegOf(si.Return()) } _64 := x.Type().Bits() == 64 @@ -1691,7 +1691,7 @@ func (m *machine) lowerBitwiseAluOp(si *ssa.Instruction, op aluOp, ignoreResult c := instr.ConstantVal() if isBitMaskImmediate(c, _64) { // Constant bit wise operations can be lowered to a single instruction. - alu.asALUBitmaskImm(op, rd.nr(), rn.nr(), c, _64) + alu.asALUBitmaskImm(op, rd, rn.nr(), c, _64) m.insert(alu) return } @@ -1709,25 +1709,25 @@ func (m *machine) lowerRotl(si *ssa.Instruction) { rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - var tmp operand + var tmp regalloc.VReg if _64 { - tmp = operandNR(m.compiler.AllocateVReg(ssa.TypeI64)) + tmp = m.compiler.AllocateVReg(ssa.TypeI64) } else { - tmp = operandNR(m.compiler.AllocateVReg(ssa.TypeI32)) + tmp = m.compiler.AllocateVReg(ssa.TypeI32) } - rd := operandNR(m.compiler.VRegOf(r)) + rd := m.compiler.VRegOf(r) // Encode rotl as neg + rotr: neg is a sub against the zero-reg. m.lowerRotlImpl(rd, rn, rm, tmp, _64) } -func (m *machine) lowerRotlImpl(rd, rn, rm, tmp operand, is64bit bool) { +func (m *machine) lowerRotlImpl(rd regalloc.VReg, rn, rm operand, tmp regalloc.VReg, is64bit bool) { // Encode rotl as neg + rotr: neg is a sub against the zero-reg. neg := m.allocateInstr() neg.asALU(aluOpSub, tmp, operandNR(xzrVReg), rm, is64bit) m.insert(neg) alu := m.allocateInstr() - alu.asALU(aluOpRotR, rd, rn, tmp, is64bit) + alu.asALU(aluOpRotR, rd, rn, operandNR(tmp), is64bit) m.insert(alu) } @@ -1737,7 +1737,7 @@ func (m *machine) lowerRotr(si *ssa.Instruction) { xDef, yDef := m.compiler.ValueDefinition(x), m.compiler.ValueDefinition(y) rn := m.getOperand_NR(xDef, extModeNone) rm := m.getOperand_NR(yDef, extModeNone) - rd := operandNR(m.compiler.VRegOf(si.Return())) + rd := m.compiler.VRegOf(si.Return()) alu := m.allocateInstr() alu.asALU(aluOpRotR, rd, rn, rm, si.Return().Type().Bits() == 64) @@ -1797,7 +1797,7 @@ func (m *machine) lowerImul(x, y, result ssa.Value) { // TODO: if this comes before Add/Sub, we could merge it by putting it into the place of xzrVReg. mul := m.allocateInstr() - mul.asALURRRR(aluOpMAdd, operandNR(rd), rn, rm, operandNR(xzrVReg), x.Type().Bits() == 64) + mul.asALURRRR(aluOpMAdd, rd, rn, rm, xzrVReg, x.Type().Bits() == 64) m.insert(mul) } @@ -1849,22 +1849,22 @@ func (m *machine) lowerPopcnt(x, result ssa.Value) { // mov x5, v0.d[0] ;; finally we mov the result back to a GPR // - rd := operandNR(m.compiler.VRegOf(result)) + rd := m.compiler.VRegOf(result) rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rf1 := operandNR(m.compiler.AllocateVReg(ssa.TypeF64)) ins := m.allocateInstr() - ins.asMovToVec(rf1, rn, vecArrangementD, vecIndex(0)) + ins.asMovToVec(rf1.nr(), rn, vecArrangementD, vecIndex(0)) m.insert(ins) rf2 := operandNR(m.compiler.AllocateVReg(ssa.TypeF64)) cnt := m.allocateInstr() - cnt.asVecMisc(vecOpCnt, rf2, rf1, vecArrangement16B) + cnt.asVecMisc(vecOpCnt, rf2.nr(), rf1, vecArrangement16B) m.insert(cnt) rf3 := operandNR(m.compiler.AllocateVReg(ssa.TypeF64)) uaddlv := m.allocateInstr() - uaddlv.asVecLanes(vecOpUaddlv, rf3, rf2, vecArrangement8B) + uaddlv.asVecLanes(vecOpUaddlv, rf3.nr(), rf2, vecArrangement8B) m.insert(uaddlv) mov := m.allocateInstr() @@ -1879,32 +1879,35 @@ func (m *machine) lowerExitWithCode(execCtxVReg regalloc.VReg, code wazevoapi.Ex loadExitCodeConst.asMOVZ(tmpReg1, uint64(code), 0, true) setExitCode := m.allocateInstr() - setExitCode.asStore(operandNR(tmpReg1), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - rn: execCtxVReg, imm: wazevoapi.ExecutionContextOffsetExitCodeOffset.I64(), - }, 32) + mode := m.amodePool.Allocate() + *mode = addressMode{ + kind: addressModeKindRegUnsignedImm12, + rn: execCtxVReg, imm: wazevoapi.ExecutionContextOffsetExitCodeOffset.I64(), + } + setExitCode.asStore(operandNR(tmpReg1), mode, 32) // In order to unwind the stack, we also need to push the current stack pointer: tmp2 := m.compiler.AllocateVReg(ssa.TypeI64) movSpToTmp := m.allocateInstr() movSpToTmp.asMove64(tmp2, spVReg) strSpToExecCtx := m.allocateInstr() - strSpToExecCtx.asStore(operandNR(tmp2), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - rn: execCtxVReg, imm: wazevoapi.ExecutionContextOffsetStackPointerBeforeGoCall.I64(), - }, 64) + mode2 := m.amodePool.Allocate() + *mode2 = addressMode{ + kind: addressModeKindRegUnsignedImm12, + rn: execCtxVReg, imm: wazevoapi.ExecutionContextOffsetStackPointerBeforeGoCall.I64(), + } + strSpToExecCtx.asStore(operandNR(tmp2), mode2, 64) // Also the address of this exit. tmp3 := m.compiler.AllocateVReg(ssa.TypeI64) currentAddrToTmp := m.allocateInstr() currentAddrToTmp.asAdr(tmp3, 0) storeCurrentAddrToExecCtx := m.allocateInstr() - storeCurrentAddrToExecCtx.asStore(operandNR(tmp3), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - rn: execCtxVReg, imm: wazevoapi.ExecutionContextOffsetGoCallReturnAddress.I64(), - }, 64) + mode3 := m.amodePool.Allocate() + *mode3 = addressMode{ + kind: addressModeKindRegUnsignedImm12, + rn: execCtxVReg, imm: wazevoapi.ExecutionContextOffsetGoCallReturnAddress.I64(), + } + storeCurrentAddrToExecCtx.asStore(operandNR(tmp3), mode3, 64) exitSeq := m.allocateInstr() exitSeq.asExitSequence(execCtxVReg) @@ -1937,7 +1940,7 @@ func (m *machine) lowerIcmpToFlag(x, y ssa.Value, signed bool) { alu.asALU( aluOpSubS, // We don't need the result, just need to set flags. - operandNR(xzrVReg), + xzrVReg, rn, rm, x.Type().Bits() == 64, @@ -2012,7 +2015,7 @@ func (m *machine) lowerSelect(c, x, y, result ssa.Value) { alu.asALU( aluOpSubS, // We don't need the result, just need to set flags. - operandNR(xzrVReg), + xzrVReg, rn, operandNR(xzrVReg), c.Type().Bits() == 64, @@ -2024,7 +2027,7 @@ func (m *machine) lowerSelect(c, x, y, result ssa.Value) { rn := m.getOperand_NR(m.compiler.ValueDefinition(x), extModeNone) rm := m.getOperand_NR(m.compiler.ValueDefinition(y), extModeNone) - rd := operandNR(m.compiler.VRegOf(result)) + rd := m.compiler.VRegOf(result) switch x.Type() { case ssa.TypeI32, ssa.TypeI64: // csel rd, rn, rm, cc @@ -2041,10 +2044,10 @@ func (m *machine) lowerSelect(c, x, y, result ssa.Value) { } } -func (m *machine) lowerSelectVec(rc, rn, rm, rd operand) { +func (m *machine) lowerSelectVec(rc, rn, rm operand, rd regalloc.VReg) { // First check if `rc` is zero or not. checkZero := m.allocateInstr() - checkZero.asALU(aluOpSubS, operandNR(xzrVReg), rc, operandNR(xzrVReg), false) + checkZero.asALU(aluOpSubS, xzrVReg, rc, operandNR(xzrVReg), false) m.insert(checkZero) // Then use CSETM to set all bits to one if `rc` is zero. @@ -2054,7 +2057,7 @@ func (m *machine) lowerSelectVec(rc, rn, rm, rd operand) { m.insert(cset) // Then move the bits to the result vector register. - tmp2 := operandNR(m.compiler.AllocateVReg(ssa.TypeV128)) + tmp2 := m.compiler.AllocateVReg(ssa.TypeV128) dup := m.allocateInstr() dup.asVecDup(tmp2, operandNR(allOnesOrZero), vecArrangement2D) m.insert(dup) @@ -2067,7 +2070,7 @@ func (m *machine) lowerSelectVec(rc, rn, rm, rd operand) { // Finally, move the result to the destination register. mov2 := m.allocateInstr() - mov2.asFpuMov128(rd.nr(), tmp2.nr()) + mov2.asFpuMov128(rd, tmp2) m.insert(mov2) } @@ -2099,28 +2102,28 @@ func (m *machine) lowerAtomicRmw(si *ssa.Instruction) { addr, val := si.Arg2() addrDef, valDef := m.compiler.ValueDefinition(addr), m.compiler.ValueDefinition(val) rn := m.getOperand_NR(addrDef, extModeNone) - rt := operandNR(m.compiler.VRegOf(si.Return())) + rt := m.compiler.VRegOf(si.Return()) rs := m.getOperand_NR(valDef, extModeNone) _64 := si.Return().Type().Bits() == 64 - var tmp operand + var tmp regalloc.VReg if _64 { - tmp = operandNR(m.compiler.AllocateVReg(ssa.TypeI64)) + tmp = m.compiler.AllocateVReg(ssa.TypeI64) } else { - tmp = operandNR(m.compiler.AllocateVReg(ssa.TypeI32)) + tmp = m.compiler.AllocateVReg(ssa.TypeI32) } - m.lowerAtomicRmwImpl(op, rn, rs, rt, tmp, size, negateArg, flipArg, _64) + m.lowerAtomicRmwImpl(op, rn.nr(), rs.nr(), rt, tmp, size, negateArg, flipArg, _64) } -func (m *machine) lowerAtomicRmwImpl(op atomicRmwOp, rn, rs, rt, tmp operand, size uint64, negateArg, flipArg, dst64bit bool) { +func (m *machine) lowerAtomicRmwImpl(op atomicRmwOp, rn, rs, rt, tmp regalloc.VReg, size uint64, negateArg, flipArg, dst64bit bool) { switch { case negateArg: neg := m.allocateInstr() - neg.asALU(aluOpSub, tmp, operandNR(xzrVReg), rs, dst64bit) + neg.asALU(aluOpSub, tmp, operandNR(xzrVReg), operandNR(rs), dst64bit) m.insert(neg) case flipArg: flip := m.allocateInstr() - flip.asALU(aluOpOrn, tmp, operandNR(xzrVReg), rs, dst64bit) + flip.asALU(aluOpOrn, tmp, operandNR(xzrVReg), operandNR(rs), dst64bit) m.insert(flip) default: tmp = rs @@ -2139,32 +2142,32 @@ func (m *machine) lowerAtomicCas(si *ssa.Instruction) { rn := m.getOperand_NR(addrDef, extModeNone) rt := m.getOperand_NR(replDef, extModeNone) rs := m.getOperand_NR(expDef, extModeNone) - tmp := operandNR(m.compiler.AllocateVReg(si.Return().Type())) + tmp := m.compiler.AllocateVReg(si.Return().Type()) _64 := si.Return().Type().Bits() == 64 // rs is overwritten by CAS, so we need to move it to the result register before the instruction // in case when it is used somewhere else. mov := m.allocateInstr() if _64 { - mov.asMove64(tmp.nr(), rs.nr()) + mov.asMove64(tmp, rs.nr()) } else { - mov.asMove32(tmp.nr(), rs.nr()) + mov.asMove32(tmp, rs.nr()) } m.insert(mov) - m.lowerAtomicCasImpl(rn, tmp, rt, size) + m.lowerAtomicCasImpl(rn.nr(), tmp, rt.nr(), size) mov2 := m.allocateInstr() rd := m.compiler.VRegOf(si.Return()) if _64 { - mov2.asMove64(rd, tmp.nr()) + mov2.asMove64(rd, tmp) } else { - mov2.asMove32(rd, tmp.nr()) + mov2.asMove32(rd, tmp) } m.insert(mov2) } -func (m *machine) lowerAtomicCasImpl(rn, rs, rt operand, size uint64) { +func (m *machine) lowerAtomicCasImpl(rn, rs, rt regalloc.VReg, size uint64) { cas := m.allocateInstr() cas.asAtomicCas(rn, rs, rt, size) m.insert(cas) @@ -2176,12 +2179,12 @@ func (m *machine) lowerAtomicLoad(si *ssa.Instruction) { addrDef := m.compiler.ValueDefinition(addr) rn := m.getOperand_NR(addrDef, extModeNone) - rt := operandNR(m.compiler.VRegOf(si.Return())) + rt := m.compiler.VRegOf(si.Return()) - m.lowerAtomicLoadImpl(rn, rt, size) + m.lowerAtomicLoadImpl(rn.nr(), rt, size) } -func (m *machine) lowerAtomicLoadImpl(rn, rt operand, size uint64) { +func (m *machine) lowerAtomicLoadImpl(rn, rt regalloc.VReg, size uint64) { ld := m.allocateInstr() ld.asAtomicLoad(rn, rt, size) m.insert(ld) diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_mem.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_mem.go index 4842eaa382..fd0760d723 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_mem.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/lower_mem.go @@ -24,6 +24,14 @@ type ( addressModeKind byte ) +func resetAddressMode(a *addressMode) { + a.kind = 0 + a.rn = 0 + a.rm = 0 + a.extOp = 0 + a.imm = 0 +} + const ( // addressModeKindRegExtended takes a base register and an index register. The index register is sign/zero-extended, // and then scaled by bits(type)/8. @@ -140,15 +148,17 @@ func (a addressMode) format(dstSizeBits byte) (ret string) { return } -func addressModePreOrPostIndex(rn regalloc.VReg, imm int64, preIndex bool) addressMode { +func addressModePreOrPostIndex(m *machine, rn regalloc.VReg, imm int64, preIndex bool) *addressMode { if !offsetFitsInAddressModeKindRegSignedImm9(imm) { panic(fmt.Sprintf("BUG: offset %#x does not fit in addressModeKindRegSignedImm9", imm)) } + mode := m.amodePool.Allocate() if preIndex { - return addressMode{kind: addressModeKindPreIndex, rn: rn, imm: imm} + *mode = addressMode{kind: addressModeKindPreIndex, rn: rn, imm: imm} } else { - return addressMode{kind: addressModeKindPostIndex, rn: rn, imm: imm} + *mode = addressMode{kind: addressModeKindPostIndex, rn: rn, imm: imm} } + return mode } func offsetFitsInAddressModeKindRegUnsignedImm12(dstSizeInBits byte, offset int64) bool { @@ -207,9 +217,9 @@ func (m *machine) lowerExtLoad(op ssa.Opcode, ptr ssa.Value, offset uint32, ret amode := m.lowerToAddressMode(ptr, offset, size) load := m.allocateInstr() if signed { - load.asSLoad(operandNR(ret), amode, size) + load.asSLoad(ret, amode, size) } else { - load.asULoad(operandNR(ret), amode, size) + load.asULoad(ret, amode, size) } m.insert(load) } @@ -221,11 +231,11 @@ func (m *machine) lowerLoad(ptr ssa.Value, offset uint32, typ ssa.Type, ret ssa. load := m.allocateInstr() switch typ { case ssa.TypeI32, ssa.TypeI64: - load.asULoad(operandNR(dst), amode, typ.Bits()) + load.asULoad(dst, amode, typ.Bits()) case ssa.TypeF32, ssa.TypeF64: - load.asFpuLoad(operandNR(dst), amode, typ.Bits()) + load.asFpuLoad(dst, amode, typ.Bits()) case ssa.TypeV128: - load.asFpuLoad(operandNR(dst), amode, 128) + load.asFpuLoad(dst, amode, 128) default: panic("TODO") } @@ -239,7 +249,7 @@ func (m *machine) lowerLoadSplat(ptr ssa.Value, offset uint32, lane ssa.VecLane, m.lowerConstantI64(offsetReg, int64(offset)) addedBase := m.addReg64ToReg64(base, offsetReg) - rd := operandNR(m.compiler.VRegOf(ret)) + rd := m.compiler.VRegOf(ret) ld1r := m.allocateInstr() ld1r.asVecLoad1R(rd, operandNR(addedBase), ssaLaneToArrangement(lane)) @@ -258,7 +268,7 @@ func (m *machine) lowerStore(si *ssa.Instruction) { } // lowerToAddressMode converts a pointer to an addressMode that can be used as an operand for load/store instructions. -func (m *machine) lowerToAddressMode(ptr ssa.Value, offsetBase uint32, size byte) (amode addressMode) { +func (m *machine) lowerToAddressMode(ptr ssa.Value, offsetBase uint32, size byte) (amode *addressMode) { // TODO: currently the instruction selection logic doesn't support addressModeKindRegScaledExtended and // addressModeKindRegScaled since collectAddends doesn't take ssa.OpcodeIshl into account. This should be fixed // to support more efficient address resolution. @@ -272,32 +282,33 @@ func (m *machine) lowerToAddressMode(ptr ssa.Value, offsetBase uint32, size byte // During the construction, this might emit additional instructions. // // Extracted as a separate function for easy testing. -func (m *machine) lowerToAddressModeFromAddends(a32s *wazevoapi.Queue[addend32], a64s *wazevoapi.Queue[regalloc.VReg], size byte, offset int64) (amode addressMode) { +func (m *machine) lowerToAddressModeFromAddends(a32s *wazevoapi.Queue[addend32], a64s *wazevoapi.Queue[regalloc.VReg], size byte, offset int64) (amode *addressMode) { + amode = m.amodePool.Allocate() switch a64sExist, a32sExist := !a64s.Empty(), !a32s.Empty(); { case a64sExist && a32sExist: var base regalloc.VReg base = a64s.Dequeue() var a32 addend32 a32 = a32s.Dequeue() - amode = addressMode{kind: addressModeKindRegExtended, rn: base, rm: a32.r, extOp: a32.ext} + *amode = addressMode{kind: addressModeKindRegExtended, rn: base, rm: a32.r, extOp: a32.ext} case a64sExist && offsetFitsInAddressModeKindRegUnsignedImm12(size, offset): var base regalloc.VReg base = a64s.Dequeue() - amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: base, imm: offset} + *amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: base, imm: offset} offset = 0 case a64sExist && offsetFitsInAddressModeKindRegSignedImm9(offset): var base regalloc.VReg base = a64s.Dequeue() - amode = addressMode{kind: addressModeKindRegSignedImm9, rn: base, imm: offset} + *amode = addressMode{kind: addressModeKindRegSignedImm9, rn: base, imm: offset} offset = 0 case a64sExist: var base regalloc.VReg base = a64s.Dequeue() if !a64s.Empty() { index := a64s.Dequeue() - amode = addressMode{kind: addressModeKindRegReg, rn: base, rm: index, extOp: extendOpUXTX /* indicates index reg is 64-bit */} + *amode = addressMode{kind: addressModeKindRegReg, rn: base, rm: index, extOp: extendOpUXTX /* indicates index reg is 64-bit */} } else { - amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: base, imm: 0} + *amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: base, imm: 0} } case a32sExist: base32 := a32s.Dequeue() @@ -314,14 +325,14 @@ func (m *machine) lowerToAddressModeFromAddends(a32s *wazevoapi.Queue[addend32], if !a32s.Empty() { index := a32s.Dequeue() - amode = addressMode{kind: addressModeKindRegExtended, rn: base, rm: index.r, extOp: index.ext} + *amode = addressMode{kind: addressModeKindRegExtended, rn: base, rm: index.r, extOp: index.ext} } else { - amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: base, imm: 0} + *amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: base, imm: 0} } default: // Only static offsets. tmpReg := m.compiler.AllocateVReg(ssa.TypeI64) m.lowerConstantI64(tmpReg, offset) - amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: tmpReg, imm: 0} + *amode = addressMode{kind: addressModeKindRegUnsignedImm12, rn: tmpReg, imm: 0} offset = 0 } @@ -411,13 +422,13 @@ func (m *machine) addConstToReg64(r regalloc.VReg, c int64) (rd regalloc.VReg) { rd = m.compiler.AllocateVReg(ssa.TypeI64) alu := m.allocateInstr() if imm12Op, ok := asImm12Operand(uint64(c)); ok { - alu.asALU(aluOpAdd, operandNR(rd), operandNR(r), imm12Op, true) + alu.asALU(aluOpAdd, rd, operandNR(r), imm12Op, true) } else if imm12Op, ok = asImm12Operand(uint64(-c)); ok { - alu.asALU(aluOpSub, operandNR(rd), operandNR(r), imm12Op, true) + alu.asALU(aluOpSub, rd, operandNR(r), imm12Op, true) } else { tmp := m.compiler.AllocateVReg(ssa.TypeI64) m.load64bitConst(c, tmp) - alu.asALU(aluOpAdd, operandNR(rd), operandNR(r), operandNR(tmp), true) + alu.asALU(aluOpAdd, rd, operandNR(r), operandNR(tmp), true) } m.insert(alu) return @@ -426,7 +437,7 @@ func (m *machine) addConstToReg64(r regalloc.VReg, c int64) (rd regalloc.VReg) { func (m *machine) addReg64ToReg64(rn, rm regalloc.VReg) (rd regalloc.VReg) { rd = m.compiler.AllocateVReg(ssa.TypeI64) alu := m.allocateInstr() - alu.asALU(aluOpAdd, operandNR(rd), operandNR(rn), operandNR(rm), true) + alu.asALU(aluOpAdd, rd, operandNR(rn), operandNR(rm), true) m.insert(alu) return } @@ -434,7 +445,7 @@ func (m *machine) addReg64ToReg64(rn, rm regalloc.VReg) (rd regalloc.VReg) { func (m *machine) addRegToReg64Ext(rn, rm regalloc.VReg, ext extendOp) (rd regalloc.VReg) { rd = m.compiler.AllocateVReg(ssa.TypeI64) alu := m.allocateInstr() - alu.asALU(aluOpAdd, operandNR(rd), operandNR(rn), operandER(rm, ext, 64), true) + alu.asALU(aluOpAdd, rd, operandNR(rn), operandER(rm, ext, 64), true) m.insert(alu) return } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine.go index b435d9ba96..5f584f928b 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine.go @@ -21,6 +21,8 @@ type ( regAlloc regalloc.Allocator regAllocFn *backend.RegAllocFunction[*instruction, *machine] + amodePool wazevoapi.Pool[addressMode] + // addendsWorkQueue is used during address lowering, defined here for reuse. addendsWorkQueue wazevoapi.Queue[ssa.Value] addends32 wazevoapi.Queue[addend32] @@ -105,6 +107,7 @@ func NewBackend() backend.Machine { spillSlots: make(map[regalloc.VRegID]int64), executableContext: newExecutableContext(), regAlloc: regalloc.NewAllocator(regInfo), + amodePool: wazevoapi.NewPool[addressMode](resetAddressMode), } return m } @@ -149,6 +152,7 @@ func (m *machine) Reset() { m.maxRequiredStackSizeForCalls = 0 m.executableContext.Reset() m.jmpTableTargets = m.jmpTableTargets[:0] + m.amodePool.Reset() } // SetCurrentABI implements backend.Machine SetCurrentABI. @@ -183,9 +187,8 @@ func (m *machine) allocateBrTarget() (nop *instruction, l label) { l = ectx.AllocateLabel() nop = m.allocateInstr() nop.asNop0WithLabel(l) - pos := ectx.AllocateLabelPosition(l) + pos := ectx.GetOrAllocateLabelPosition(l) pos.Begin, pos.End = nop, nop - ectx.LabelPositions[l] = pos return } @@ -209,7 +212,7 @@ func (m *machine) allocateNop() *instruction { } func (m *machine) resolveAddressingMode(arg0offset, ret0offset int64, i *instruction) { - amode := &i.amode + amode := i.getAmode() switch amode.kind { case addressModeKindResultStackSpace: amode.imm += ret0offset @@ -281,7 +284,7 @@ func (m *machine) resolveRelativeAddresses(ctx context.Context) { switch cur.kind { case nop0: l := cur.nop0Label() - if pos, ok := ectx.LabelPositions[l]; ok { + if pos := ectx.LabelPositions[l]; pos != nil { pos.BinaryOffset = offset + size } case condBr: @@ -428,8 +431,10 @@ func (m *machine) insertConditionalJumpTrampoline(cbr *instruction, currentBlk * func (m *machine) Format() string { ectx := m.executableContext begins := map[*instruction]label{} - for l, pos := range ectx.LabelPositions { - begins[pos.Begin] = l + for _, pos := range ectx.LabelPositions { + if pos != nil { + begins[pos.Begin] = pos.L + } } irBlocks := map[label]ssa.BasicBlockID{} diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine_pro_epi_logue.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine_pro_epi_logue.go index 466fac4640..d9032f9218 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine_pro_epi_logue.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine_pro_epi_logue.go @@ -70,7 +70,7 @@ func (m *machine) setupPrologue() { // +-----------------+ <----- SP // (low address) // - _amode := addressModePreOrPostIndex(spVReg, + _amode := addressModePreOrPostIndex(m, spVReg, -16, // stack pointer must be 16-byte aligned. true, // Decrement before store. ) @@ -159,7 +159,7 @@ func (m *machine) createReturnAddrAndSizeOfArgRetSlot(cur *instruction) *instruc sizeOfArgRetReg = tmpRegVReg subSp := m.allocateInstr() - subSp.asALU(aluOpSub, operandNR(spVReg), operandNR(spVReg), operandNR(sizeOfArgRetReg), true) + subSp.asALU(aluOpSub, spVReg, operandNR(spVReg), operandNR(sizeOfArgRetReg), true) cur = linkInstr(cur, subSp) } else { sizeOfArgRetReg = xzrVReg @@ -168,7 +168,7 @@ func (m *machine) createReturnAddrAndSizeOfArgRetSlot(cur *instruction) *instruc // Saves the return address (lr) and the size_of_arg_ret below the SP. // size_of_arg_ret is used for stack unwinding. pstr := m.allocateInstr() - amode := addressModePreOrPostIndex(spVReg, -16, true /* decrement before store */) + amode := addressModePreOrPostIndex(m, spVReg, -16, true /* decrement before store */) pstr.asStorePair64(lrVReg, sizeOfArgRetReg, amode) cur = linkInstr(cur, pstr) return cur @@ -182,7 +182,7 @@ func (m *machine) createFrameSizeSlot(cur *instruction, s int64) *instruction { } else { frameSizeReg = xzrVReg } - _amode := addressModePreOrPostIndex(spVReg, + _amode := addressModePreOrPostIndex(m, spVReg, -16, // stack pointer must be 16-byte aligned. true, // Decrement before store. ) @@ -213,7 +213,7 @@ func (m *machine) postRegAlloc() { m.executableContext.PendingInstructions = m.executableContext.PendingInstructions[:0] default: // Removes the redundant copy instruction. - if cur.IsCopy() && cur.rn.realReg() == cur.rd.realReg() { + if cur.IsCopy() && cur.rn.realReg() == cur.rd.RealReg() { prev, next := cur.prev, cur.next // Remove the copy instruction. prev.next = next @@ -286,16 +286,16 @@ func (m *machine) setupEpilogueAfter(cur *instruction) { for i := range m.clobberedRegs { vr := m.clobberedRegs[l-i] // reverse order to restore. load := m.allocateInstr() - amode := addressModePreOrPostIndex(spVReg, + amode := addressModePreOrPostIndex(m, spVReg, 16, // stack pointer must be 16-byte aligned. false, // Increment after store. ) // TODO: pair loads to reduce the number of instructions. switch regTypeToRegisterSizeInBits(vr.RegType()) { case 64: // save int reg. - load.asULoad(operandNR(vr), amode, 64) + load.asULoad(vr, amode, 64) case 128: // save vector reg. - load.asFpuLoad(operandNR(vr), amode, 128) + load.asFpuLoad(vr, amode, 128) } cur = linkInstr(cur, load) } @@ -317,8 +317,8 @@ func (m *machine) setupEpilogueAfter(cur *instruction) { // SP----> +-----------------+ ldr := m.allocateInstr() - ldr.asULoad(operandNR(lrVReg), - addressModePreOrPostIndex(spVReg, 16 /* stack pointer must be 16-byte aligned. */, false /* increment after loads */), 64) + ldr.asULoad(lrVReg, + addressModePreOrPostIndex(m, spVReg, 16 /* stack pointer must be 16-byte aligned. */, false /* increment after loads */), 64) cur = linkInstr(cur, ldr) if s := int64(m.currentABI.AlignedArgResultStackSlotSize()); s > 0 { @@ -351,14 +351,14 @@ func (m *machine) insertStackBoundsCheck(requiredStackSize int64, cur *instructi if immm12op, ok := asImm12Operand(uint64(requiredStackSize)); ok { // sub tmp, sp, #requiredStackSize sub := m.allocateInstr() - sub.asALU(aluOpSub, operandNR(tmpRegVReg), operandNR(spVReg), immm12op, true) + sub.asALU(aluOpSub, tmpRegVReg, operandNR(spVReg), immm12op, true) cur = linkInstr(cur, sub) } else { // This case, we first load the requiredStackSize into the temporary register, cur = m.lowerConstantI64AndInsert(cur, tmpRegVReg, requiredStackSize) // Then subtract it. sub := m.allocateInstr() - sub.asALU(aluOpSub, operandNR(tmpRegVReg), operandNR(spVReg), operandNR(tmpRegVReg), true) + sub.asALU(aluOpSub, tmpRegVReg, operandNR(spVReg), operandNR(tmpRegVReg), true) cur = linkInstr(cur, sub) } @@ -366,16 +366,18 @@ func (m *machine) insertStackBoundsCheck(requiredStackSize int64, cur *instructi // ldr tmp2, [executionContext #StackBottomPtr] ldr := m.allocateInstr() - ldr.asULoad(operandNR(tmp2), addressMode{ + amode := m.amodePool.Allocate() + *amode = addressMode{ kind: addressModeKindRegUnsignedImm12, rn: x0VReg, // execution context is always the first argument. imm: wazevoapi.ExecutionContextOffsetStackBottomPtr.I64(), - }, 64) + } + ldr.asULoad(tmp2, amode, 64) cur = linkInstr(cur, ldr) // subs xzr, tmp, tmp2 subs := m.allocateInstr() - subs.asALU(aluOpSubS, operandNR(xzrVReg), operandNR(tmpRegVReg), operandNR(tmp2), true) + subs.asALU(aluOpSubS, xzrVReg, operandNR(tmpRegVReg), operandNR(tmp2), true) cur = linkInstr(cur, subs) // b.ge #imm @@ -388,22 +390,25 @@ func (m *machine) insertStackBoundsCheck(requiredStackSize int64, cur *instructi // First load the requiredStackSize into the temporary register, cur = m.lowerConstantI64AndInsert(cur, tmpRegVReg, requiredStackSize) setRequiredStackSize := m.allocateInstr() - setRequiredStackSize.asStore(operandNR(tmpRegVReg), - addressMode{ - kind: addressModeKindRegUnsignedImm12, - // Execution context is always the first argument. - rn: x0VReg, imm: wazevoapi.ExecutionContextOffsetStackGrowRequiredSize.I64(), - }, 64) + amode := m.amodePool.Allocate() + *amode = addressMode{ + kind: addressModeKindRegUnsignedImm12, + // Execution context is always the first argument. + rn: x0VReg, imm: wazevoapi.ExecutionContextOffsetStackGrowRequiredSize.I64(), + } + setRequiredStackSize.asStore(operandNR(tmpRegVReg), amode, 64) cur = linkInstr(cur, setRequiredStackSize) } ldrAddress := m.allocateInstr() - ldrAddress.asULoad(operandNR(tmpRegVReg), addressMode{ + amode2 := m.amodePool.Allocate() + *amode2 = addressMode{ kind: addressModeKindRegUnsignedImm12, rn: x0VReg, // execution context is always the first argument imm: wazevoapi.ExecutionContextOffsetStackGrowCallTrampolineAddress.I64(), - }, 64) + } + ldrAddress.asULoad(tmpRegVReg, amode2, 64) cur = linkInstr(cur, ldrAddress) // Then jumps to the stack grow call sequence's address, meaning diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine_regalloc.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine_regalloc.go index 1c8793b73d..c7eb92cc20 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine_regalloc.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/isa/arm64/machine_regalloc.go @@ -91,7 +91,7 @@ func (m *machine) InsertStoreRegisterAt(v regalloc.VReg, instr *instruction, aft } offsetFromSP := m.getVRegSpillSlotOffsetFromSP(v.ID(), typ.Size()) - var amode addressMode + var amode *addressMode cur, amode = m.resolveAddressModeForOffsetAndInsert(cur, offsetFromSP, typ.Bits(), spVReg, true) store := m.allocateInstr() store.asStore(operandNR(v), amode, typ.Bits()) @@ -116,16 +116,16 @@ func (m *machine) InsertReloadRegisterAt(v regalloc.VReg, instr *instruction, af } offsetFromSP := m.getVRegSpillSlotOffsetFromSP(v.ID(), typ.Size()) - var amode addressMode + var amode *addressMode cur, amode = m.resolveAddressModeForOffsetAndInsert(cur, offsetFromSP, typ.Bits(), spVReg, true) load := m.allocateInstr() switch typ { case ssa.TypeI32, ssa.TypeI64: - load.asULoad(operandNR(v), amode, typ.Bits()) + load.asULoad(v, amode, typ.Bits()) case ssa.TypeF32, ssa.TypeF64: - load.asFpuLoad(operandNR(v), amode, typ.Bits()) + load.asFpuLoad(v, amode, typ.Bits()) case ssa.TypeV128: - load.asFpuLoad(operandNR(v), amode, 128) + load.asFpuLoad(v, amode, 128) default: panic("TODO") } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc.go index 3f36c84e57..6553707860 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc.go @@ -35,7 +35,7 @@ type ( iter int reversePostOrderBlocks []RegAllocBlock[I, m] // labelToRegAllocBlockIndex maps label to the index of reversePostOrderBlocks. - labelToRegAllocBlockIndex map[Label]int + labelToRegAllocBlockIndex [] /* Label to */ int loopNestingForestRoots []ssa.BasicBlock } @@ -56,10 +56,9 @@ type ( // NewRegAllocFunction returns a new RegAllocFunction. func NewRegAllocFunction[I regalloc.InstrConstraint, M RegAllocFunctionMachine[I]](m M, ssb ssa.Builder, c Compiler) *RegAllocFunction[I, M] { return &RegAllocFunction[I, M]{ - m: m, - ssb: ssb, - c: c, - labelToRegAllocBlockIndex: make(map[Label]int), + m: m, + ssb: ssb, + c: c, } } @@ -74,6 +73,9 @@ func (f *RegAllocFunction[I, M]) AddBlock(sb ssa.BasicBlock, l Label, begin, end end: end, id: int(sb.ID()), }) + if len(f.labelToRegAllocBlockIndex) <= int(l) { + f.labelToRegAllocBlockIndex = append(f.labelToRegAllocBlockIndex, make([]int, int(l)-len(f.labelToRegAllocBlockIndex)+1)...) + } f.labelToRegAllocBlockIndex[l] = i } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc/regalloc.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc/regalloc.go index b4450d56fb..eacb6a7ef9 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc/regalloc.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc/regalloc.go @@ -60,9 +60,8 @@ type ( phiDefInstListPool wazevoapi.Pool[phiDefInstList] // Followings are re-used during various places. - blks []Block - reals []RealReg - currentOccupants regInUseSet + blks []Block + reals []RealReg // Following two fields are updated while iterating the blocks in the reverse postorder. state state @@ -755,7 +754,8 @@ func (a *Allocator) allocBlock(f Function, blk Block) { killSet := a.reals[:0] // Gather the set of registers that will be used in the current instruction. - for _, use := range instr.Uses(&a.vs) { + uses := instr.Uses(&a.vs) + for _, use := range uses { if use.IsRealReg() { r := use.RealReg() currentUsedSet = currentUsedSet.add(r) @@ -770,7 +770,7 @@ func (a *Allocator) allocBlock(f Function, blk Block) { } } - for i, use := range instr.Uses(&a.vs) { + for i, use := range uses { if !use.IsRealReg() { vs := s.getVRegState(use.ID()) killed := vs.lastUse == pc @@ -944,8 +944,7 @@ func (a *Allocator) allocBlock(f Function, blk Block) { func (a *Allocator) releaseCallerSavedRegs(addrReg RealReg) { s := &a.state - for i := 0; i < 64; i++ { - allocated := RealReg(i) + for allocated := RealReg(0); allocated < 64; allocated++ { if allocated == addrReg { // If this is the call indirect, we should not touch the addr register. continue } @@ -974,11 +973,10 @@ func (a *Allocator) fixMergeState(f Function, blk Block) { bID := blk.ID() blkSt := a.getOrAllocateBlockState(bID) desiredOccupants := &blkSt.startRegs - aliveOnRegVRegs := make(map[VReg]RealReg) - for i := 0; i < 64; i++ { - r := RealReg(i) - if v := blkSt.startRegs.get(r); v.Valid() { - aliveOnRegVRegs[v] = r + var desiredOccupantsSet RegSet + for i, v := range desiredOccupants { + if v != VRegInvalid { + desiredOccupantsSet = desiredOccupantsSet.add(RealReg(i)) } } @@ -987,56 +985,38 @@ func (a *Allocator) fixMergeState(f Function, blk Block) { } s.currentBlockID = bID - a.updateLiveInVRState(a.getOrAllocateBlockState(bID)) + a.updateLiveInVRState(blkSt) - currentOccupants := &a.currentOccupants for i := 0; i < preds; i++ { - currentOccupants.reset() if i == blkSt.startFromPredIndex { continue } - currentOccupantsRev := make(map[VReg]RealReg) pred := blk.Pred(i) predSt := a.getOrAllocateBlockState(pred.ID()) - for ii := 0; ii < 64; ii++ { - r := RealReg(ii) - if v := predSt.endRegs.get(r); v.Valid() { - if _, ok := aliveOnRegVRegs[v]; !ok { - continue - } - currentOccupants.add(r, v) - currentOccupantsRev[v] = r - } - } s.resetAt(predSt) // Finds the free registers if any. intTmp, floatTmp := VRegInvalid, VRegInvalid if intFree := s.findAllocatable( - a.regInfo.AllocatableRegisters[RegTypeInt], desiredOccupants.set, + a.regInfo.AllocatableRegisters[RegTypeInt], desiredOccupantsSet, ); intFree != RealRegInvalid { intTmp = FromRealReg(intFree, RegTypeInt) } if floatFree := s.findAllocatable( - a.regInfo.AllocatableRegisters[RegTypeFloat], desiredOccupants.set, + a.regInfo.AllocatableRegisters[RegTypeFloat], desiredOccupantsSet, ); floatFree != RealRegInvalid { floatTmp = FromRealReg(floatFree, RegTypeFloat) } - if wazevoapi.RegAllocLoggingEnabled { - fmt.Println("\t", pred.ID(), ":", currentOccupants.format(a.regInfo)) - } - - for ii := 0; ii < 64; ii++ { - r := RealReg(ii) + for r := RealReg(0); r < 64; r++ { desiredVReg := desiredOccupants.get(r) if !desiredVReg.Valid() { continue } - currentVReg := currentOccupants.get(r) + currentVReg := s.regsInUse.get(r) if desiredVReg.ID() == currentVReg.ID() { continue } @@ -1048,86 +1028,95 @@ func (a *Allocator) fixMergeState(f Function, blk Block) { } else { tmpRealReg = floatTmp } - a.reconcileEdge(f, r, pred, currentOccupants, currentOccupantsRev, currentVReg, desiredVReg, tmpRealReg, typ) + a.reconcileEdge(f, r, pred, currentVReg, desiredVReg, tmpRealReg, typ) } } } +// reconcileEdge reconciles the register state between the current block and the predecessor for the real register `r`. +// +// - currentVReg is the current VReg value that sits on the register `r`. This can be VRegInvalid if the register is not used at the end of the predecessor. +// - desiredVReg is the desired VReg value that should be on the register `r`. +// - freeReg is the temporary register that can be used to swap the values, which may or may not be used. +// - typ is the register type of the `r`. func (a *Allocator) reconcileEdge(f Function, r RealReg, pred Block, - currentOccupants *regInUseSet, - currentOccupantsRev map[VReg]RealReg, currentVReg, desiredVReg VReg, freeReg VReg, typ RegType, ) { + // There are four cases to consider: + // 1. currentVReg is valid, but desiredVReg is on the stack. + // 2. Both currentVReg and desiredVReg are valid. + // 3. Desired is on a different register than `r` and currentReg is not valid. + // 4. Desired is on the stack and currentReg is not valid. + s := &a.state if currentVReg.Valid() { - // Both are on reg. - er, ok := currentOccupantsRev[desiredVReg] - if !ok { + desiredState := s.getVRegState(desiredVReg.ID()) + er := desiredState.r + if er == RealRegInvalid { + // Case 1: currentVReg is valid, but desiredVReg is on the stack. if wazevoapi.RegAllocLoggingEnabled { fmt.Printf("\t\tv%d is desired to be on %s, but currently on the stack\n", desiredVReg.ID(), a.regInfo.RealRegName(r), ) } - // This case is that the desired value is on the stack, but currentVReg is on the target register. - // We need to move the current value to the stack, and reload the desired value. + // We need to move the current value to the stack, and reload the desired value into the register. // TODO: we can do better here. f.StoreRegisterBefore(currentVReg.SetRealReg(r), pred.LastInstrForInsertion()) - delete(currentOccupantsRev, currentVReg) + s.releaseRealReg(r) s.getVRegState(desiredVReg.ID()).recordReload(f, pred) f.ReloadRegisterBefore(desiredVReg.SetRealReg(r), pred.LastInstrForInsertion()) - currentOccupants.add(r, desiredVReg) - currentOccupantsRev[desiredVReg] = r + s.useRealReg(r, desiredVReg) return - } - - if wazevoapi.RegAllocLoggingEnabled { - fmt.Printf("\t\tv%d is desired to be on %s, but currently on %s\n", - desiredVReg.ID(), a.regInfo.RealRegName(r), a.regInfo.RealRegName(er), + } else { + // Case 2: Both currentVReg and desiredVReg are valid. + if wazevoapi.RegAllocLoggingEnabled { + fmt.Printf("\t\tv%d is desired to be on %s, but currently on %s\n", + desiredVReg.ID(), a.regInfo.RealRegName(r), a.regInfo.RealRegName(er), + ) + } + // This case, we need to swap the values between the current and desired values. + f.SwapBefore( + currentVReg.SetRealReg(r), + desiredVReg.SetRealReg(er), + freeReg, + pred.LastInstrForInsertion(), ) - } - f.SwapBefore( - currentVReg.SetRealReg(r), - desiredVReg.SetRealReg(er), - freeReg, - pred.LastInstrForInsertion(), - ) - s.allocatedRegSet = s.allocatedRegSet.add(freeReg.RealReg()) - currentOccupantsRev[desiredVReg] = r - currentOccupantsRev[currentVReg] = er - currentOccupants.add(r, desiredVReg) - currentOccupants.add(er, currentVReg) - if wazevoapi.RegAllocLoggingEnabled { - fmt.Printf("\t\tv%d previously on %s moved to %s\n", currentVReg.ID(), a.regInfo.RealRegName(r), a.regInfo.RealRegName(er)) + s.allocatedRegSet = s.allocatedRegSet.add(freeReg.RealReg()) + s.releaseRealReg(r) + s.releaseRealReg(er) + s.useRealReg(r, desiredVReg) + s.useRealReg(er, currentVReg) + if wazevoapi.RegAllocLoggingEnabled { + fmt.Printf("\t\tv%d previously on %s moved to %s\n", currentVReg.ID(), a.regInfo.RealRegName(r), a.regInfo.RealRegName(er)) + } } } else { - // Desired is on reg, but currently the target register is not used. if wazevoapi.RegAllocLoggingEnabled { fmt.Printf("\t\tv%d is desired to be on %s, current not used\n", desiredVReg.ID(), a.regInfo.RealRegName(r), ) } - if currentReg, ok := currentOccupantsRev[desiredVReg]; ok { + if currentReg := s.getVRegState(desiredVReg.ID()).r; currentReg != RealRegInvalid { + // Case 3: Desired is on a different register than `r` and currentReg is not valid. + // We simply need to move the desired value to the register. f.InsertMoveBefore( FromRealReg(r, typ), desiredVReg.SetRealReg(currentReg), pred.LastInstrForInsertion(), ) - currentOccupants.remove(currentReg) + s.releaseRealReg(currentReg) } else { + // Case 4: Both currentVReg and desiredVReg are not valid. + // We simply need to reload the desired value into the register. s.getVRegState(desiredVReg.ID()).recordReload(f, pred) f.ReloadRegisterBefore(desiredVReg.SetRealReg(r), pred.LastInstrForInsertion()) } - currentOccupantsRev[desiredVReg] = r - currentOccupants.add(r, desiredVReg) - } - - if wazevoapi.RegAllocLoggingEnabled { - fmt.Println("\t", pred.ID(), ":", currentOccupants.format(a.regInfo)) + s.useRealReg(r, desiredVReg) } } @@ -1169,8 +1158,7 @@ func (a *Allocator) scheduleSpill(f Function, vs *vrState) { } for pos != definingBlk { st := a.getOrAllocateBlockState(pos.ID()) - for ii := 0; ii < 64; ii++ { - rr := RealReg(ii) + for rr := RealReg(0); rr < 64; rr++ { if st.startRegs.get(rr) == v { r = rr // Already in the register, so we can place the spill at the beginning of the block. diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc/regset.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc/regset.go index e9bf60661c..04a8e8f4db 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc/regset.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc/regset.go @@ -46,23 +46,24 @@ func (rs RegSet) Range(f func(allocatedRealReg RealReg)) { } } -type regInUseSet struct { - set RegSet - vrs [64]VReg +type regInUseSet [64]VReg + +func newRegInUseSet() regInUseSet { + var ret regInUseSet + ret.reset() + return ret } func (rs *regInUseSet) reset() { - rs.set = 0 - for i := range rs.vrs { - rs.vrs[i] = VRegInvalid + for i := range rs { + rs[i] = VRegInvalid } } func (rs *regInUseSet) format(info *RegisterInfo) string { //nolint:unused var ret []string - for i := 0; i < 64; i++ { - if rs.set&(1<v%d)", info.RealRegName(RealReg(i)), vr.ID())) } } @@ -70,39 +71,28 @@ func (rs *regInUseSet) format(info *RegisterInfo) string { //nolint:unused } func (rs *regInUseSet) has(r RealReg) bool { - if r >= 64 { - return false - } - return rs.set&(1<= 64 { - return VRegInvalid - } - return rs.vrs[r] + return rs[r] } func (rs *regInUseSet) remove(r RealReg) { - if r >= 64 { - return - } - rs.set &= ^(1 << uint(r)) - rs.vrs[r] = VRegInvalid + rs[r] = VRegInvalid } func (rs *regInUseSet) add(r RealReg, vr VReg) { if r >= 64 { return } - rs.set |= 1 << uint(r) - rs.vrs[r] = vr + rs[r] = vr } func (rs *regInUseSet) range_(f func(allocatedRealReg RealReg, vr VReg)) { - for i := 0; i < 64; i++ { - if rs.set&(1< 0 { - b = uint64(uintptr(unsafe.Pointer(&mem.Buffer[0]))) - } - binary.LittleEndian.PutUint64(opaque[offset:], b) - binary.LittleEndian.PutUint64(opaque[offset+8:], s) -} - func (m *moduleEngine) setupOpaque() { inst := m.module offsets := &m.parent.offsets @@ -106,7 +96,7 @@ func (m *moduleEngine) setupOpaque() { ) if lm := offsets.LocalMemoryBegin; lm >= 0 { - putLocalMemory(opaque, lm, inst.MemoryInstance) + m.putLocalMemory() } // Note: imported memory is resolved in ResolveImportedFunction. @@ -227,6 +217,25 @@ func (m *moduleEngine) SetGlobalValue(i wasm.Index, lo, hi uint64) { // OwnsGlobals implements the same method as documented on wasm.ModuleEngine. func (m *moduleEngine) OwnsGlobals() bool { return true } +// MemoryGrown implements wasm.ModuleEngine. +func (m *moduleEngine) MemoryGrown() { + m.putLocalMemory() +} + +// putLocalMemory writes the local memory buffer pointer and length to the opaque buffer. +func (m *moduleEngine) putLocalMemory() { + mem := m.module.MemoryInstance + offset := m.parent.offsets.LocalMemoryBegin + + s := uint64(len(mem.Buffer)) + var b uint64 + if len(mem.Buffer) > 0 { + b = uint64(uintptr(unsafe.Pointer(&mem.Buffer[0]))) + } + binary.LittleEndian.PutUint64(m.opaque[offset:], b) + binary.LittleEndian.PutUint64(m.opaque[offset+8:], s) +} + // ResolveImportedFunction implements wasm.ModuleEngine. func (m *moduleEngine) ResolveImportedFunction(index, indexInImportedModule wasm.Index, importedModuleEngine wasm.ModuleEngine) { executableOffset, moduleCtxOffset, typeIDOffset := m.parent.offsets.ImportedFunctionOffset(index) diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/basic_block.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/basic_block.go index 10b6b4b62b..39627b9898 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/basic_block.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/basic_block.go @@ -49,21 +49,12 @@ type BasicBlock interface { // ReturnBlock returns ture if this block represents the function return. ReturnBlock() bool - // FormatHeader returns the debug string of this block, not including instruction. - FormatHeader(b Builder) string - // Valid is true if this block is still valid even after optimizations. Valid() bool // Sealed is true if this block has been sealed. Sealed() bool - // BeginPredIterator returns the first predecessor of this block. - BeginPredIterator() BasicBlock - - // NextPredIterator returns the next predecessor of this block. - NextPredIterator() BasicBlock - // Preds returns the number of predecessors of this block. Preds() int @@ -88,10 +79,11 @@ type ( basicBlock struct { id BasicBlockID rootInstr, currentInstr *Instruction - params []blockParam - predIter int - preds []basicBlockPredecessorInfo - success []*basicBlock + // params are Values that represent parameters to a basicBlock. + // Each parameter can be considered as an output of PHI instruction in traditional SSA. + params []Value + preds []basicBlockPredecessorInfo + success []*basicBlock // singlePred is the alias to preds[0] for fast lookup, and only set after Seal is called. singlePred *basicBlock // lastDefinitions maps Variable to its last definition in this block. @@ -116,11 +108,14 @@ type ( // loopNestingForestChildren holds the children of this block in the loop nesting forest. // Non-empty if and only if this block is a loop header (i.e. loopHeader=true) - loopNestingForestChildren []BasicBlock + loopNestingForestChildren wazevoapi.VarLength[BasicBlock] // reversePostOrder is used to sort all the blocks in the function in reverse post order. // This is used in builder.LayoutBlocks. - reversePostOrder int + reversePostOrder int32 + + // visited is used during various traversals. + visited int32 // child and sibling are the ones in the dominator tree. child, sibling *basicBlock @@ -128,15 +123,6 @@ type ( // BasicBlockID is the unique ID of a basicBlock. BasicBlockID uint32 - // blockParam implements Value and represents a parameter to a basicBlock. - blockParam struct { - // value is the Value that corresponds to the parameter in this block, - // and can be considered as an output of PHI instruction in traditional SSA. - value Value - // typ is the type of the parameter. - typ Type - } - unknownValue struct { // variable is the variable that this unknownValue represents. variable Variable @@ -145,6 +131,9 @@ type ( } ) +// basicBlockVarLengthNil is the default nil value for basicBlock.loopNestingForestChildren. +var basicBlockVarLengthNil = wazevoapi.NewNilVarLength[BasicBlock]() + const basicBlockIDReturnBlock = 0xffffffff // Name implements BasicBlock.Name. @@ -190,13 +179,13 @@ func (bb *basicBlock) ReturnBlock() bool { // AddParam implements BasicBlock.AddParam. func (bb *basicBlock) AddParam(b Builder, typ Type) Value { paramValue := b.allocateValue(typ) - bb.params = append(bb.params, blockParam{typ: typ, value: paramValue}) + bb.params = append(bb.params, paramValue) return paramValue } // addParamOn adds a parameter to this block whose value is already allocated. -func (bb *basicBlock) addParamOn(typ Type, value Value) { - bb.params = append(bb.params, blockParam{typ: typ, value: value}) +func (bb *basicBlock) addParamOn(value Value) { + bb.params = append(bb.params, value) } // Params implements BasicBlock.Params. @@ -206,8 +195,7 @@ func (bb *basicBlock) Params() int { // Param implements BasicBlock.Param. func (bb *basicBlock) Param(i int) Value { - p := &bb.params[i] - return p.value + return bb.params[i] } // Valid implements BasicBlock.Valid. @@ -248,22 +236,6 @@ func (bb *basicBlock) NumPreds() int { return len(bb.preds) } -// BeginPredIterator implements BasicBlock.BeginPredIterator. -func (bb *basicBlock) BeginPredIterator() BasicBlock { - bb.predIter = 0 - return bb.NextPredIterator() -} - -// NextPredIterator implements BasicBlock.NextPredIterator. -func (bb *basicBlock) NextPredIterator() BasicBlock { - if bb.predIter >= len(bb.preds) { - return nil - } - pred := bb.preds[bb.predIter].blk - bb.predIter++ - return pred -} - // Preds implements BasicBlock.Preds. func (bb *basicBlock) Preds() int { return len(bb.preds) @@ -305,7 +277,8 @@ func resetBasicBlock(bb *basicBlock) { bb.unknownValues = bb.unknownValues[:0] bb.lastDefinitions = wazevoapi.ResetMap(bb.lastDefinitions) bb.reversePostOrder = -1 - bb.loopNestingForestChildren = bb.loopNestingForestChildren[:0] + bb.visited = 0 + bb.loopNestingForestChildren = basicBlockVarLengthNil bb.loopHeader = false bb.sibling = nil bb.child = nil @@ -335,11 +308,11 @@ func (bb *basicBlock) addPred(blk BasicBlock, branch *Instruction) { pred.success = append(pred.success, bb) } -// FormatHeader implements BasicBlock.FormatHeader. -func (bb *basicBlock) FormatHeader(b Builder) string { +// formatHeader returns the string representation of the header of the basicBlock. +func (bb *basicBlock) formatHeader(b Builder) string { ps := make([]string, len(bb.params)) for i, p := range bb.params { - ps[i] = p.value.formatWithType(b) + ps[i] = p.formatWithType(b) } if len(bb.preds) > 0 { @@ -398,7 +371,7 @@ func (bb *basicBlock) String() string { // LoopNestingForestChildren implements BasicBlock.LoopNestingForestChildren. func (bb *basicBlock) LoopNestingForestChildren() []BasicBlock { - return bb.loopNestingForestChildren + return bb.loopNestingForestChildren.View() } // LoopHeader implements BasicBlock.LoopHeader. diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/builder.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/builder.go index 1fc84d2eaf..0b700c4b19 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/builder.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/builder.go @@ -54,9 +54,6 @@ type Builder interface { // MustFindValue searches the latest definition of the given Variable and returns the result. MustFindValue(variable Variable) Value - // MustFindValueInBlk is the same as MustFindValue except it searches the latest definition from the given BasicBlock. - MustFindValueInBlk(variable Variable, blk BasicBlock) Value - // FindValueInLinearPath tries to find the latest definition of the given Variable in the linear path to the current BasicBlock. // If it cannot find the definition, or it's not sealed yet, it returns ValueInvalid. FindValueInLinearPath(variable Variable) Value @@ -127,7 +124,11 @@ type Builder interface { // Idom returns the immediate dominator of the given BasicBlock. Idom(blk BasicBlock) BasicBlock + // VarLengthPool returns the VarLengthPool of Value. VarLengthPool() *wazevoapi.VarLengthPool[Value] + + // InsertZeroValue inserts a zero value constant instruction of the given type. + InsertZeroValue(t Type) } // NewBuilder returns a new Builder implementation. @@ -135,10 +136,10 @@ func NewBuilder() Builder { return &builder{ instructionsPool: wazevoapi.NewPool[Instruction](resetInstruction), basicBlocksPool: wazevoapi.NewPool[basicBlock](resetBasicBlock), + varLengthBasicBlockPool: wazevoapi.NewVarLengthPool[BasicBlock](), varLengthPool: wazevoapi.NewVarLengthPool[Value](), valueAnnotations: make(map[ValueID]string), signatures: make(map[SignatureID]*Signature), - blkVisited: make(map[*basicBlock]int), valueIDAliases: make(map[ValueID]Value), redundantParameterIndexToValue: make(map[int]Value), returnBlk: &basicBlock{id: basicBlockIDReturnBlock}, @@ -177,12 +178,13 @@ type builder struct { dominators []*basicBlock sparseTree dominatorSparseTree + varLengthBasicBlockPool wazevoapi.VarLengthPool[BasicBlock] + // loopNestingForestRoots are the roots of the loop nesting forest. loopNestingForestRoots []BasicBlock // The followings are used for optimization passes/deterministic compilation. instStack []*Instruction - blkVisited map[*basicBlock]int valueIDToInstruction []*Instruction blkStack []*basicBlock blkStack2 []*basicBlock @@ -200,6 +202,32 @@ type builder struct { donePostBlockLayoutPasses bool currentSourceOffset SourceOffset + + // zeros are the zero value constants for each type. + zeros [typeEnd]Value +} + +// InsertZeroValue implements Builder.InsertZeroValue. +func (b *builder) InsertZeroValue(t Type) { + if b.zeros[t].Valid() { + return + } + zeroInst := b.AllocateInstruction() + switch t { + case TypeI32: + zeroInst.AsIconst32(0) + case TypeI64: + zeroInst.AsIconst64(0) + case TypeF32: + zeroInst.AsF32const(0) + case TypeF64: + zeroInst.AsF64const(0) + case TypeV128: + zeroInst.AsVconst(0, 0) + default: + panic("TODO: " + t.String()) + } + b.zeros[t] = zeroInst.Insert(b).Return() } func (b *builder) VarLengthPool() *wazevoapi.VarLengthPool[Value] { @@ -215,10 +243,12 @@ func (b *builder) ReturnBlock() BasicBlock { func (b *builder) Init(s *Signature) { b.nextVariable = 0 b.currentSignature = s + b.zeros = [typeEnd]Value{ValueInvalid, ValueInvalid, ValueInvalid, ValueInvalid, ValueInvalid, ValueInvalid} resetBasicBlock(b.returnBlk) b.instructionsPool.Reset() b.basicBlocksPool.Reset() b.varLengthPool.Reset() + b.varLengthBasicBlockPool.Reset() b.donePreBlockLayoutPasses = false b.doneBlockLayout = false b.donePostBlockLayoutPasses = false @@ -231,11 +261,6 @@ func (b *builder) Init(s *Signature) { b.blkStack2 = b.blkStack2[:0] b.dominators = b.dominators[:0] b.loopNestingForestRoots = b.loopNestingForestRoots[:0] - - for i := 0; i < b.basicBlocksPool.Allocated(); i++ { - blk := b.basicBlocksPool.View(i) - delete(b.blkVisited, blk) - } b.basicBlocksPool.Reset() for v := ValueID(0); v < b.nextValueID; v++ { @@ -448,11 +473,6 @@ func (b *builder) findValueInLinearPath(variable Variable, blk *basicBlock) Valu return ValueInvalid } -func (b *builder) MustFindValueInBlk(variable Variable, blk BasicBlock) Value { - typ := b.definedVariableType(variable) - return b.findValue(typ, variable, blk.(*basicBlock)) -} - // MustFindValue implements Builder.MustFindValue. func (b *builder) MustFindValue(variable Variable) Value { typ := b.definedVariableType(variable) @@ -482,6 +502,9 @@ func (b *builder) findValue(typ Type, variable Variable, blk *basicBlock) Value value: value, }) return value + } else if blk.EntryBlock() { + // If this is the entry block, we reach the uninitialized variable which has zero value. + return b.zeros[b.definedVariableType(variable)] } if pred := blk.singlePred; pred != nil { @@ -495,21 +518,42 @@ func (b *builder) findValue(typ Type, variable Variable, blk *basicBlock) Value // If this block has multiple predecessors, we have to gather the definitions, // and treat them as an argument to this block. // - // The first thing is to define a new parameter to this block which may or may not be redundant, but - // later we eliminate trivial params in an optimization pass. This must be done before finding the - // definitions in the predecessors so that we can break the cycle. - paramValue := blk.AddParam(b, typ) - b.DefineVariable(variable, paramValue, blk) - - // After the new param is added, we have to manipulate the original branching instructions - // in predecessors so that they would pass the definition of `variable` as the argument to - // the newly added PHI. + // But before that, we have to check if the possible definitions are the same Value. + tmpValue := b.allocateValue(typ) + // Break the cycle by defining the variable with the tmpValue. + b.DefineVariable(variable, tmpValue, blk) + // Check all the predecessors if they have the same definition. + uniqueValue := ValueInvalid for i := range blk.preds { - pred := &blk.preds[i] - value := b.findValue(typ, variable, pred.blk) - pred.branch.addArgumentBranchInst(b, value) + predValue := b.findValue(typ, variable, blk.preds[i].blk) + if uniqueValue == ValueInvalid { + uniqueValue = predValue + } else if uniqueValue != predValue { + uniqueValue = ValueInvalid + break + } + } + + if uniqueValue != ValueInvalid { + // If all the predecessors have the same definition, we can use that value. + b.DefineVariable(variable, uniqueValue, blk) + b.alias(tmpValue, uniqueValue) + return uniqueValue + } else { + // Otherwise, add the tmpValue to this block as a parameter which may or may not be redundant, but + // later we eliminate trivial params in an optimization pass. This must be done before finding the + // definitions in the predecessors so that we can break the cycle. + blk.addParamOn(tmpValue) + // After the new param is added, we have to manipulate the original branching instructions + // in predecessors so that they would pass the definition of `variable` as the argument to + // the newly added PHI. + for i := range blk.preds { + pred := &blk.preds[i] + value := b.findValue(typ, variable, pred.blk) + pred.branch.addArgumentBranchInst(b, value) + } + return tmpValue } - return paramValue } // Seal implements Builder.Seal. @@ -523,7 +567,7 @@ func (b *builder) Seal(raw BasicBlock) { for _, v := range blk.unknownValues { variable, phiValue := v.variable, v.value typ := b.definedVariableType(variable) - blk.addParamOn(typ, phiValue) + blk.addParamOn(phiValue) for i := range blk.preds { pred := &blk.preds[i] predValue := b.findValue(typ, variable, pred.blk) @@ -566,7 +610,7 @@ func (b *builder) Format() string { } for bb := iterBegin(); bb != nil; bb = iterNext() { str.WriteByte('\n') - str.WriteString(bb.FormatHeader(b)) + str.WriteString(bb.formatHeader(b)) str.WriteByte('\n') for cur := bb.Root(); cur != nil; cur = cur.Next() { diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass.go index a2e986cd15..89ec34b7eb 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass.go @@ -22,9 +22,9 @@ func (b *builder) RunPasses() { func (b *builder) runPreBlockLayoutPasses() { passSortSuccessors(b) passDeadBlockEliminationOpt(b) - passRedundantPhiEliminationOpt(b) // The result of passCalculateImmediateDominators will be used by various passes below. passCalculateImmediateDominators(b) + passRedundantPhiEliminationOpt(b) passNopInstElimination(b) // TODO: implement either conversion of irreducible CFG into reducible one, or irreducible CFG detection where we panic. @@ -78,12 +78,11 @@ func (b *builder) runFinalizingPasses() { // passDeadBlockEliminationOpt searches the unreachable blocks, and sets the basicBlock.invalid flag true if so. func passDeadBlockEliminationOpt(b *builder) { entryBlk := b.entryBlk() - b.clearBlkVisited() b.blkStack = append(b.blkStack, entryBlk) for len(b.blkStack) > 0 { reachableBlk := b.blkStack[len(b.blkStack)-1] b.blkStack = b.blkStack[:len(b.blkStack)-1] - b.blkVisited[reachableBlk] = 0 // the value won't be used in this pass. + reachableBlk.visited = 1 if !reachableBlk.sealed && !reachableBlk.ReturnBlock() { panic(fmt.Sprintf("%s is not sealed", reachableBlk)) @@ -94,7 +93,7 @@ func passDeadBlockEliminationOpt(b *builder) { } for _, succ := range reachableBlk.success { - if _, ok := b.blkVisited[succ]; ok { + if succ.visited == 1 { continue } b.blkStack = append(b.blkStack, succ) @@ -102,13 +101,16 @@ func passDeadBlockEliminationOpt(b *builder) { } for blk := b.blockIteratorBegin(); blk != nil; blk = b.blockIteratorNext() { - if _, ok := b.blkVisited[blk]; !ok { + if blk.visited != 1 { blk.invalid = true } + blk.visited = 0 } } // passRedundantPhiEliminationOpt eliminates the redundant PHIs (in our terminology, parameters of a block). +// This requires the reverse post-order traversal to be calculated before calling this function, +// hence passCalculateImmediateDominators must be called before this. func passRedundantPhiEliminationOpt(b *builder) { redundantParameterIndexes := b.ints[:0] // reuse the slice from previous iterations. @@ -118,15 +120,18 @@ func passRedundantPhiEliminationOpt(b *builder) { // relatively small. For example, sqlite speedtest binary results in the large number of redundant PHIs, // the maximum number of iteration was 22, which seems to be acceptable but not that small either since the // complexity here is O(BlockNum * Iterations) at the worst case where BlockNum might be the order of thousands. + // -- Note -- + // Currently, each iteration can run in any order of blocks, but it empirically converges quickly in practice when + // running on the reverse post-order. It might be possible to optimize this further by using the dominator tree. for { changed := false - _ = b.blockIteratorBegin() // skip entry block! + _ = b.blockIteratorReversePostOrderBegin() // skip entry block! // Below, we intentionally use the named iteration variable name, as this comes with inevitable nested for loops! - for blk := b.blockIteratorNext(); blk != nil; blk = b.blockIteratorNext() { + for blk := b.blockIteratorReversePostOrderNext(); blk != nil; blk = b.blockIteratorReversePostOrderNext() { paramNum := len(blk.params) for paramIndex := 0; paramIndex < paramNum; paramIndex++ { - phiValue := blk.params[paramIndex].value + phiValue := blk.params[paramIndex] redundant := true nonSelfReferencingValue := ValueInvalid @@ -184,7 +189,7 @@ func passRedundantPhiEliminationOpt(b *builder) { // Still need to have the definition of the value of the PHI (previously as the parameter). for _, redundantParamIndex := range redundantParameterIndexes { - phiValue := blk.params[redundantParamIndex].value + phiValue := blk.params[redundantParamIndex] onlyValue := b.redundantParameterIndexToValue[redundantParamIndex] // Create an alias in this block from the only phi argument to the phi value. b.alias(phiValue, onlyValue) @@ -227,10 +232,10 @@ func passRedundantPhiEliminationOpt(b *builder) { func passDeadCodeEliminationOpt(b *builder) { nvid := int(b.nextValueID) if nvid >= len(b.valueRefCounts) { - b.valueRefCounts = append(b.valueRefCounts, make([]int, b.nextValueID)...) + b.valueRefCounts = append(b.valueRefCounts, make([]int, nvid-len(b.valueRefCounts)+1)...) } if nvid >= len(b.valueIDToInstruction) { - b.valueIDToInstruction = append(b.valueIDToInstruction, make([]*Instruction, b.nextValueID)...) + b.valueIDToInstruction = append(b.valueIDToInstruction, make([]*Instruction, nvid-len(b.valueIDToInstruction)+1)...) } // First, we gather all the instructions with side effects. @@ -350,22 +355,10 @@ func (b *builder) incRefCount(id ValueID, from *Instruction) { b.valueRefCounts[id]++ } -// clearBlkVisited clears the b.blkVisited map so that we can reuse it for multiple places. -func (b *builder) clearBlkVisited() { - b.blkStack2 = b.blkStack2[:0] - for key := range b.blkVisited { - b.blkStack2 = append(b.blkStack2, key) - } - for _, blk := range b.blkStack2 { - delete(b.blkVisited, blk) - } - b.blkStack2 = b.blkStack2[:0] -} - // passNopInstElimination eliminates the instructions which is essentially a no-op. func passNopInstElimination(b *builder) { if int(b.nextValueID) >= len(b.valueIDToInstruction) { - b.valueIDToInstruction = append(b.valueIDToInstruction, make([]*Instruction, b.nextValueID)...) + b.valueIDToInstruction = append(b.valueIDToInstruction, make([]*Instruction, int(b.nextValueID)-len(b.valueIDToInstruction)+1)...) } for blk := b.blockIteratorBegin(); blk != nil; blk = b.blockIteratorNext() { diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass_blk_layouts.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass_blk_layouts.go index 9068180a0b..584b5eadea 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass_blk_layouts.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass_blk_layouts.go @@ -23,8 +23,6 @@ import ( // // This heuristic is done in maybeInvertBranches function. func passLayoutBlocks(b *builder) { - b.clearBlkVisited() - // We might end up splitting critical edges which adds more basic blocks, // so we store the currently existing basic blocks in nonSplitBlocks temporarily. // That way we can iterate over the original basic blocks while appending new ones into reversePostOrderedBasicBlocks. @@ -47,20 +45,20 @@ func passLayoutBlocks(b *builder) { for _, blk := range nonSplitBlocks { for i := range blk.preds { pred := blk.preds[i].blk - if _, ok := b.blkVisited[pred]; ok || !pred.Valid() { + if pred.visited == 1 || !pred.Valid() { continue } else if pred.reversePostOrder < blk.reversePostOrder { // This means the edge is critical, and this pred is the trampoline and yet to be inserted. // Split edge trampolines must come before the destination in reverse post-order. b.reversePostOrderedBasicBlocks = append(b.reversePostOrderedBasicBlocks, pred) - b.blkVisited[pred] = 0 // mark as inserted, the value is not used. + pred.visited = 1 // mark as inserted. } } // Now that we've already added all the potential trampoline blocks incoming to this block, // we can add this block itself. b.reversePostOrderedBasicBlocks = append(b.reversePostOrderedBasicBlocks, blk) - b.blkVisited[blk] = 0 // mark as inserted, the value is not used. + blk.visited = 1 // mark as inserted. if len(blk.success) < 2 { // There won't be critical edge originating from this block. @@ -116,7 +114,7 @@ func passLayoutBlocks(b *builder) { if fallthroughBranch.opcode == OpcodeJump && fallthroughBranch.blk == trampoline { // This can be lowered as fallthrough at the end of the block. b.reversePostOrderedBasicBlocks = append(b.reversePostOrderedBasicBlocks, trampoline) - b.blkVisited[trampoline] = 0 // mark as inserted, the value is not used. + trampoline.visited = 1 // mark as inserted. } else { uninsertedTrampolines = append(uninsertedTrampolines, trampoline) } @@ -126,7 +124,7 @@ func passLayoutBlocks(b *builder) { if trampoline.success[0].reversePostOrder <= trampoline.reversePostOrder { // "<=", not "<" because the target might be itself. // This means the critical edge was backward, so we insert after the current block immediately. b.reversePostOrderedBasicBlocks = append(b.reversePostOrderedBasicBlocks, trampoline) - b.blkVisited[trampoline] = 0 // mark as inserted, the value is not used. + trampoline.visited = 1 // mark as inserted. } // If the target is forward, we can wait to insert until the target is inserted. } uninsertedTrampolines = uninsertedTrampolines[:0] // Reuse the stack for the next block. @@ -142,8 +140,8 @@ func passLayoutBlocks(b *builder) { if wazevoapi.SSAValidationEnabled { for _, trampoline := range trampolines { - if _, ok := b.blkVisited[trampoline]; !ok { - panic("BUG: trampoline block not inserted: " + trampoline.FormatHeader(b)) + if trampoline.visited != 1 { + panic("BUG: trampoline block not inserted: " + trampoline.formatHeader(b)) } trampoline.validate(b) } diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass_cfg.go b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass_cfg.go index 50cb9c4750..e8288c4bd3 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass_cfg.go +++ b/vendor/github.com/tetratelabs/wazero/internal/engine/wazevo/ssa/pass_cfg.go @@ -15,10 +15,6 @@ import ( // At the last of pass, this function also does the loop detection and sets the basicBlock.loop flag. func passCalculateImmediateDominators(b *builder) { reversePostOrder := b.reversePostOrderedBasicBlocks[:0] - exploreStack := b.blkStack[:0] - b.clearBlkVisited() - - entryBlk := b.entryBlk() // Store the reverse postorder from the entrypoint into reversePostOrder slice. // This calculation of reverse postorder is not described in the paper, @@ -28,14 +24,17 @@ func passCalculateImmediateDominators(b *builder) { // which is a reasonable assumption as long as SSA Builder is properly used. // // First we push blocks in postorder iteratively visit successors of the entry block. - exploreStack = append(exploreStack, entryBlk) + entryBlk := b.entryBlk() + exploreStack := append(b.blkStack[:0], entryBlk) + // These flags are used to track the state of the block in the DFS traversal. + // We temporarily use the reversePostOrder field to store the state. const visitStateUnseen, visitStateSeen, visitStateDone = 0, 1, 2 - b.blkVisited[entryBlk] = visitStateSeen + entryBlk.visited = visitStateSeen for len(exploreStack) > 0 { tail := len(exploreStack) - 1 blk := exploreStack[tail] exploreStack = exploreStack[:tail] - switch b.blkVisited[blk] { + switch blk.visited { case visitStateUnseen: // This is likely a bug in the frontend. panic("BUG: unsupported CFG") @@ -48,16 +47,18 @@ func passCalculateImmediateDominators(b *builder) { if succ.ReturnBlock() || succ.invalid { continue } - if b.blkVisited[succ] == visitStateUnseen { - b.blkVisited[succ] = visitStateSeen + if succ.visited == visitStateUnseen { + succ.visited = visitStateSeen exploreStack = append(exploreStack, succ) } } // Finally, we could pop this block once we pop all of its successors. - b.blkVisited[blk] = visitStateDone + blk.visited = visitStateDone case visitStateDone: // Note: at this point we push blk in postorder despite its name. reversePostOrder = append(reversePostOrder, blk) + default: + panic("BUG") } } // At this point, reversePostOrder has postorder actually, so we reverse it. @@ -67,7 +68,7 @@ func passCalculateImmediateDominators(b *builder) { } for i, blk := range reversePostOrder { - blk.reversePostOrder = i + blk.reversePostOrder = int32(i) } // Reuse the dominators slice if possible from the previous computation of function. @@ -180,7 +181,7 @@ func passBuildLoopNestingForest(b *builder) { b.loopNestingForestRoots = append(b.loopNestingForestRoots, blk) } else if n == ent { } else if n.loopHeader { - n.loopNestingForestChildren = append(n.loopNestingForestChildren, blk) + n.loopNestingForestChildren = n.loopNestingForestChildren.Append(&b.varLengthBasicBlockPool, blk) } } @@ -193,7 +194,7 @@ func passBuildLoopNestingForest(b *builder) { func printLoopNestingForest(root *basicBlock, depth int) { fmt.Println(strings.Repeat("\t", depth), "loop nesting forest root:", root.ID()) - for _, child := range root.loopNestingForestChildren { + for _, child := range root.loopNestingForestChildren.View() { fmt.Println(strings.Repeat("\t", depth+1), "child:", child.ID()) if child.LoopHeader() { printLoopNestingForest(child.(*basicBlock), depth+2) @@ -202,10 +203,10 @@ func printLoopNestingForest(root *basicBlock, depth int) { } type dominatorSparseTree struct { - time int + time int32 euler []*basicBlock - first, depth []int - table [][]int + first, depth []int32 + table [][]int32 } // passBuildDominatorTree builds the dominator tree for the function, and constructs builder.sparseTree. @@ -232,11 +233,11 @@ func passBuildDominatorTree(b *builder) { n := b.basicBlocksPool.Allocated() st := &b.sparseTree st.euler = append(st.euler[:0], make([]*basicBlock, 2*n-1)...) - st.first = append(st.first[:0], make([]int, n)...) + st.first = append(st.first[:0], make([]int32, n)...) for i := range st.first { st.first[i] = -1 } - st.depth = append(st.depth[:0], make([]int, 2*n-1)...) + st.depth = append(st.depth[:0], make([]int32, 2*n-1)...) st.time = 0 // Start building the sparse tree. @@ -244,9 +245,9 @@ func passBuildDominatorTree(b *builder) { st.buildSparseTable() } -func (dt *dominatorSparseTree) eulerTour(node *basicBlock, height int) { +func (dt *dominatorSparseTree) eulerTour(node *basicBlock, height int32) { if wazevoapi.SSALoggingEnabled { - fmt.Println(strings.Repeat("\t", height), "euler tour:", node.ID()) + fmt.Println(strings.Repeat("\t", int(height)), "euler tour:", node.ID()) } dt.euler[dt.time] = node dt.depth[dt.time] = height @@ -270,13 +271,13 @@ func (dt *dominatorSparseTree) buildSparseTable() { table := dt.table if n >= len(table) { - table = append(table, make([][]int, n+1)...) + table = append(table, make([][]int32, n-len(table)+1)...) } for i := range table { if len(table[i]) < k { - table[i] = append(table[i], make([]int, k)...) + table[i] = append(table[i], make([]int32, k-len(table[i]))...) } - table[i][0] = i + table[i][0] = int32(i) } for j := 1; 1< 0 { - m.NonStaticLocals[idx] = nonStaticLocals - } - functionType := &m.TypeSection[m.FunctionSection[idx]] code := &m.CodeSection[idx] body := code.Body @@ -357,7 +352,6 @@ func (m *Module) validateFunctionWithMaxStackValues( return fmt.Errorf("invalid local index for %s %d >= %d(=len(locals)+len(parameters))", OpcodeLocalSetName, index, l) } - nonStaticLocals[index] = struct{}{} var expType ValueType if index < inputLen { expType = functionType.Params[index] @@ -373,7 +367,6 @@ func (m *Module) validateFunctionWithMaxStackValues( return fmt.Errorf("invalid local index for %s %d >= %d(=len(locals)+len(parameters))", OpcodeLocalTeeName, index, l) } - nonStaticLocals[index] = struct{}{} var expType ValueType if index < inputLen { expType = functionType.Params[index] diff --git a/vendor/github.com/tetratelabs/wazero/internal/wasm/memory.go b/vendor/github.com/tetratelabs/wazero/internal/wasm/memory.go index 5cc5012dae..947b16112d 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/wasm/memory.go +++ b/vendor/github.com/tetratelabs/wazero/internal/wasm/memory.go @@ -59,11 +59,14 @@ type MemoryInstance struct { // with a fixed weight of 1 and no spurious notifications. waiters sync.Map + // ownerModuleEngine is the module engine that owns this memory instance. + ownerModuleEngine ModuleEngine + expBuffer experimental.LinearMemory } // NewMemoryInstance creates a new instance based on the parameters in the SectionIDMemory. -func NewMemoryInstance(memSec *Memory, allocator experimental.MemoryAllocator) *MemoryInstance { +func NewMemoryInstance(memSec *Memory, allocator experimental.MemoryAllocator, moduleEngine ModuleEngine) *MemoryInstance { minBytes := MemoryPagesToBytesNum(memSec.Min) capBytes := MemoryPagesToBytesNum(memSec.Cap) maxBytes := MemoryPagesToBytesNum(memSec.Max) @@ -89,12 +92,13 @@ func NewMemoryInstance(memSec *Memory, allocator experimental.MemoryAllocator) * buffer = make([]byte, minBytes, capBytes) } return &MemoryInstance{ - Buffer: buffer, - Min: memSec.Min, - Cap: memoryBytesNumToPages(uint64(cap(buffer))), - Max: memSec.Max, - Shared: memSec.IsShared, - expBuffer: expBuffer, + Buffer: buffer, + Min: memSec.Min, + Cap: memoryBytesNumToPages(uint64(cap(buffer))), + Max: memSec.Max, + Shared: memSec.IsShared, + expBuffer: expBuffer, + ownerModuleEngine: moduleEngine, } } @@ -247,14 +251,12 @@ func (m *MemoryInstance) Grow(delta uint32) (result uint32, ok bool) { m.Buffer = buffer m.Cap = newPages } - return currentPages, true } else if newPages > m.Cap { // grow the memory. if m.Shared { panic("shared memory cannot be grown, this is a bug in wazero") } m.Buffer = append(m.Buffer, make([]byte, MemoryPagesToBytesNum(delta))...) m.Cap = newPages - return currentPages, true } else { // We already have the capacity we need. if m.Shared { // We assume grow is called under a guest lock. @@ -264,8 +266,9 @@ func (m *MemoryInstance) Grow(delta uint32) (result uint32, ok bool) { } else { m.Buffer = m.Buffer[:MemoryPagesToBytesNum(newPages)] } - return currentPages, true } + m.ownerModuleEngine.MemoryGrown() + return currentPages, true } // Pages implements the same method as documented on api.Memory. diff --git a/vendor/github.com/tetratelabs/wazero/internal/wasm/module.go b/vendor/github.com/tetratelabs/wazero/internal/wasm/module.go index 68573b918e..8369ad9ed6 100644 --- a/vendor/github.com/tetratelabs/wazero/internal/wasm/module.go +++ b/vendor/github.com/tetratelabs/wazero/internal/wasm/module.go @@ -185,9 +185,6 @@ type Module struct { // as described in https://yurydelendik.github.io/webassembly-dwarf/, though it is not specified in the Wasm // specification: https://github.com/WebAssembly/debugging/issues/1 DWARFLines *wasmdebug.DWARFLines - - // NonStaticLocals collects the local indexes that will change its value through either local.get or local.tee. - NonStaticLocals []map[Index]struct{} } // ModuleID represents sha256 hash value uniquely assigned to Module. @@ -366,8 +363,6 @@ func (m *Module) validateFunctions(enabledFeatures api.CoreFeatures, functions [ br := bytes.NewReader(nil) // Also, we reuse the stacks across multiple function validations to reduce allocations. vs := &stacks{} - // Non-static locals are gathered during validation and used in the down-stream compilation. - m.NonStaticLocals = make([]map[Index]struct{}, len(m.FunctionSection)) for idx, typeIndex := range m.FunctionSection { if typeIndex >= typeCount { return fmt.Errorf("invalid %s: type section index %d out of range", m.funcDesc(SectionIDFunction, Index(idx)), typeIndex) @@ -655,7 +650,7 @@ func paramNames(localNames IndirectNameMap, funcIdx uint32, paramLen int) []stri func (m *ModuleInstance) buildMemory(module *Module, allocator experimental.MemoryAllocator) { memSec := module.MemorySection if memSec != nil { - m.MemoryInstance = NewMemoryInstance(memSec, allocator) + m.MemoryInstance = NewMemoryInstance(memSec, allocator, m.Engine) m.MemoryInstance.definition = &module.MemoryDefinitionSection[0] } } diff --git a/vendor/golang.org/x/crypto/acme/http.go b/vendor/golang.org/x/crypto/acme/http.go index 58836e5d30..d92ff232fe 100644 --- a/vendor/golang.org/x/crypto/acme/http.go +++ b/vendor/golang.org/x/crypto/acme/http.go @@ -15,6 +15,7 @@ import ( "io" "math/big" "net/http" + "runtime/debug" "strconv" "strings" "time" @@ -271,9 +272,27 @@ func (c *Client) httpClient() *http.Client { } // packageVersion is the version of the module that contains this package, for -// sending as part of the User-Agent header. It's set in version_go112.go. +// sending as part of the User-Agent header. var packageVersion string +func init() { + // Set packageVersion if the binary was built in modules mode and x/crypto + // was not replaced with a different module. + info, ok := debug.ReadBuildInfo() + if !ok { + return + } + for _, m := range info.Deps { + if m.Path != "golang.org/x/crypto" { + continue + } + if m.Replace == nil { + packageVersion = m.Version + } + break + } +} + // userAgent returns the User-Agent header value. It includes the package name, // the module version (if available), and the c.UserAgent value (if set). func (c *Client) userAgent() string { diff --git a/vendor/golang.org/x/crypto/acme/version_go112.go b/vendor/golang.org/x/crypto/acme/version_go112.go deleted file mode 100644 index cc5fab604b..0000000000 --- a/vendor/golang.org/x/crypto/acme/version_go112.go +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright 2019 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:build go1.12 - -package acme - -import "runtime/debug" - -func init() { - // Set packageVersion if the binary was built in modules mode and x/crypto - // was not replaced with a different module. - info, ok := debug.ReadBuildInfo() - if !ok { - return - } - for _, m := range info.Deps { - if m.Path != "golang.org/x/crypto" { - continue - } - if m.Replace == nil { - packageVersion = m.Version - } - break - } -} diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s.go b/vendor/golang.org/x/crypto/blake2s/blake2s.go index e3f46aab3a..c25d07d4f4 100644 --- a/vendor/golang.org/x/crypto/blake2s/blake2s.go +++ b/vendor/golang.org/x/crypto/blake2s/blake2s.go @@ -16,9 +16,10 @@ // // BLAKE2X is a construction to compute hash values larger than 32 bytes. It // can produce hash values between 0 and 65535 bytes. -package blake2s // import "golang.org/x/crypto/blake2s" +package blake2s import ( + "crypto" "encoding/binary" "errors" "hash" @@ -55,6 +56,13 @@ func Sum256(data []byte) [Size]byte { // and BinaryUnmarshaler for state (de)serialization as documented by hash.Hash. func New256(key []byte) (hash.Hash, error) { return newDigest(Size, key) } +func init() { + crypto.RegisterHash(crypto.BLAKE2s_256, func() hash.Hash { + h, _ := New256(nil) + return h + }) +} + // New128 returns a new hash.Hash computing the BLAKE2s-128 checksum given a // non-empty key. Note that a 128-bit digest is too small to be secure as a // cryptographic hash and should only be used as a MAC, thus the key argument diff --git a/vendor/golang.org/x/crypto/blake2s/register.go b/vendor/golang.org/x/crypto/blake2s/register.go deleted file mode 100644 index 3156148a42..0000000000 --- a/vendor/golang.org/x/crypto/blake2s/register.go +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright 2017 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:build go1.9 - -package blake2s - -import ( - "crypto" - "hash" -) - -func init() { - newHash256 := func() hash.Hash { - h, _ := New256(nil) - return h - } - - crypto.RegisterHash(crypto.BLAKE2s_256, newHash256) -} diff --git a/vendor/golang.org/x/crypto/blowfish/cipher.go b/vendor/golang.org/x/crypto/blowfish/cipher.go index 213bf204af..0898956807 100644 --- a/vendor/golang.org/x/crypto/blowfish/cipher.go +++ b/vendor/golang.org/x/crypto/blowfish/cipher.go @@ -11,7 +11,7 @@ // Deprecated: any new system should use AES (from crypto/aes, if necessary in // an AEAD mode like crypto/cipher.NewGCM) or XChaCha20-Poly1305 (from // golang.org/x/crypto/chacha20poly1305). -package blowfish // import "golang.org/x/crypto/blowfish" +package blowfish // The code is a port of Bruce Schneier's C implementation. // See https://www.schneier.com/blowfish.html. diff --git a/vendor/golang.org/x/crypto/cast5/cast5.go b/vendor/golang.org/x/crypto/cast5/cast5.go index 425e8eecb0..016e90215c 100644 --- a/vendor/golang.org/x/crypto/cast5/cast5.go +++ b/vendor/golang.org/x/crypto/cast5/cast5.go @@ -11,7 +11,7 @@ // Deprecated: any new system should use AES (from crypto/aes, if necessary in // an AEAD mode like crypto/cipher.NewGCM) or XChaCha20-Poly1305 (from // golang.org/x/crypto/chacha20poly1305). -package cast5 // import "golang.org/x/crypto/cast5" +package cast5 import ( "errors" diff --git a/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go b/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go index 93da7322bc..8cf5d8112e 100644 --- a/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go +++ b/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go @@ -5,7 +5,7 @@ // Package chacha20poly1305 implements the ChaCha20-Poly1305 AEAD and its // extended nonce variant XChaCha20-Poly1305, as specified in RFC 8439 and // draft-irtf-cfrg-xchacha-01. -package chacha20poly1305 // import "golang.org/x/crypto/chacha20poly1305" +package chacha20poly1305 import ( "crypto/cipher" diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519.go b/vendor/golang.org/x/crypto/curve25519/curve25519.go index 00f963ea20..21ca3b2ee4 100644 --- a/vendor/golang.org/x/crypto/curve25519/curve25519.go +++ b/vendor/golang.org/x/crypto/curve25519/curve25519.go @@ -6,9 +6,11 @@ // performs scalar multiplication on the elliptic curve known as Curve25519. // See RFC 7748. // -// Starting in Go 1.20, this package is a wrapper for the X25519 implementation +// This package is a wrapper for the X25519 implementation // in the crypto/ecdh package. -package curve25519 // import "golang.org/x/crypto/curve25519" +package curve25519 + +import "crypto/ecdh" // ScalarMult sets dst to the product scalar * point. // @@ -16,7 +18,13 @@ package curve25519 // import "golang.org/x/crypto/curve25519" // zeroes, irrespective of the scalar. Instead, use the X25519 function, which // will return an error. func ScalarMult(dst, scalar, point *[32]byte) { - scalarMult(dst, scalar, point) + if _, err := x25519(dst, scalar[:], point[:]); err != nil { + // The only error condition for x25519 when the inputs are 32 bytes long + // is if the output would have been the all-zero value. + for i := range dst { + dst[i] = 0 + } + } } // ScalarBaseMult sets dst to the product scalar * base where base is the @@ -25,7 +33,12 @@ func ScalarMult(dst, scalar, point *[32]byte) { // It is recommended to use the X25519 function with Basepoint instead, as // copying into fixed size arrays can lead to unexpected bugs. func ScalarBaseMult(dst, scalar *[32]byte) { - scalarBaseMult(dst, scalar) + curve := ecdh.X25519() + priv, err := curve.NewPrivateKey(scalar[:]) + if err != nil { + panic("curve25519: internal error: scalarBaseMult was not 32 bytes") + } + copy(dst[:], priv.PublicKey().Bytes()) } const ( @@ -57,3 +70,21 @@ func X25519(scalar, point []byte) ([]byte, error) { var dst [32]byte return x25519(&dst, scalar, point) } + +func x25519(dst *[32]byte, scalar, point []byte) ([]byte, error) { + curve := ecdh.X25519() + pub, err := curve.NewPublicKey(point) + if err != nil { + return nil, err + } + priv, err := curve.NewPrivateKey(scalar) + if err != nil { + return nil, err + } + out, err := priv.ECDH(pub) + if err != nil { + return nil, err + } + copy(dst[:], out) + return dst[:], nil +} diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519_compat.go b/vendor/golang.org/x/crypto/curve25519/curve25519_compat.go deleted file mode 100644 index ba647e8d77..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/curve25519_compat.go +++ /dev/null @@ -1,105 +0,0 @@ -// Copyright 2019 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:build !go1.20 - -package curve25519 - -import ( - "crypto/subtle" - "errors" - "strconv" - - "golang.org/x/crypto/curve25519/internal/field" -) - -func scalarMult(dst, scalar, point *[32]byte) { - var e [32]byte - - copy(e[:], scalar[:]) - e[0] &= 248 - e[31] &= 127 - e[31] |= 64 - - var x1, x2, z2, x3, z3, tmp0, tmp1 field.Element - x1.SetBytes(point[:]) - x2.One() - x3.Set(&x1) - z3.One() - - swap := 0 - for pos := 254; pos >= 0; pos-- { - b := e[pos/8] >> uint(pos&7) - b &= 1 - swap ^= int(b) - x2.Swap(&x3, swap) - z2.Swap(&z3, swap) - swap = int(b) - - tmp0.Subtract(&x3, &z3) - tmp1.Subtract(&x2, &z2) - x2.Add(&x2, &z2) - z2.Add(&x3, &z3) - z3.Multiply(&tmp0, &x2) - z2.Multiply(&z2, &tmp1) - tmp0.Square(&tmp1) - tmp1.Square(&x2) - x3.Add(&z3, &z2) - z2.Subtract(&z3, &z2) - x2.Multiply(&tmp1, &tmp0) - tmp1.Subtract(&tmp1, &tmp0) - z2.Square(&z2) - - z3.Mult32(&tmp1, 121666) - x3.Square(&x3) - tmp0.Add(&tmp0, &z3) - z3.Multiply(&x1, &z2) - z2.Multiply(&tmp1, &tmp0) - } - - x2.Swap(&x3, swap) - z2.Swap(&z3, swap) - - z2.Invert(&z2) - x2.Multiply(&x2, &z2) - copy(dst[:], x2.Bytes()) -} - -func scalarBaseMult(dst, scalar *[32]byte) { - checkBasepoint() - scalarMult(dst, scalar, &basePoint) -} - -func x25519(dst *[32]byte, scalar, point []byte) ([]byte, error) { - var in [32]byte - if l := len(scalar); l != 32 { - return nil, errors.New("bad scalar length: " + strconv.Itoa(l) + ", expected 32") - } - if l := len(point); l != 32 { - return nil, errors.New("bad point length: " + strconv.Itoa(l) + ", expected 32") - } - copy(in[:], scalar) - if &point[0] == &Basepoint[0] { - scalarBaseMult(dst, &in) - } else { - var base, zero [32]byte - copy(base[:], point) - scalarMult(dst, &in, &base) - if subtle.ConstantTimeCompare(dst[:], zero[:]) == 1 { - return nil, errors.New("bad input point: low order point") - } - } - return dst[:], nil -} - -func checkBasepoint() { - if subtle.ConstantTimeCompare(Basepoint, []byte{ - 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - }) != 1 { - panic("curve25519: global Basepoint value was modified") - } -} diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519_go120.go b/vendor/golang.org/x/crypto/curve25519/curve25519_go120.go deleted file mode 100644 index 627df49727..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/curve25519_go120.go +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright 2022 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:build go1.20 - -package curve25519 - -import "crypto/ecdh" - -func x25519(dst *[32]byte, scalar, point []byte) ([]byte, error) { - curve := ecdh.X25519() - pub, err := curve.NewPublicKey(point) - if err != nil { - return nil, err - } - priv, err := curve.NewPrivateKey(scalar) - if err != nil { - return nil, err - } - out, err := priv.ECDH(pub) - if err != nil { - return nil, err - } - copy(dst[:], out) - return dst[:], nil -} - -func scalarMult(dst, scalar, point *[32]byte) { - if _, err := x25519(dst, scalar[:], point[:]); err != nil { - // The only error condition for x25519 when the inputs are 32 bytes long - // is if the output would have been the all-zero value. - for i := range dst { - dst[i] = 0 - } - } -} - -func scalarBaseMult(dst, scalar *[32]byte) { - curve := ecdh.X25519() - priv, err := curve.NewPrivateKey(scalar[:]) - if err != nil { - panic("curve25519: internal error: scalarBaseMult was not 32 bytes") - } - copy(dst[:], priv.PublicKey().Bytes()) -} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/README b/vendor/golang.org/x/crypto/curve25519/internal/field/README deleted file mode 100644 index e25bca7dc8..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/README +++ /dev/null @@ -1,7 +0,0 @@ -This package is kept in sync with crypto/ed25519/internal/edwards25519/field in -the standard library. - -If there are any changes in the standard library that need to be synced to this -package, run sync.sh. It will not overwrite any local changes made since the -previous sync, so it's ok to land changes in this package first, and then sync -to the standard library later. diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe.go deleted file mode 100644 index ca841ad99e..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/fe.go +++ /dev/null @@ -1,416 +0,0 @@ -// Copyright (c) 2017 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Package field implements fast arithmetic modulo 2^255-19. -package field - -import ( - "crypto/subtle" - "encoding/binary" - "math/bits" -) - -// Element represents an element of the field GF(2^255-19). Note that this -// is not a cryptographically secure group, and should only be used to interact -// with edwards25519.Point coordinates. -// -// This type works similarly to math/big.Int, and all arguments and receivers -// are allowed to alias. -// -// The zero value is a valid zero element. -type Element struct { - // An element t represents the integer - // t.l0 + t.l1*2^51 + t.l2*2^102 + t.l3*2^153 + t.l4*2^204 - // - // Between operations, all limbs are expected to be lower than 2^52. - l0 uint64 - l1 uint64 - l2 uint64 - l3 uint64 - l4 uint64 -} - -const maskLow51Bits uint64 = (1 << 51) - 1 - -var feZero = &Element{0, 0, 0, 0, 0} - -// Zero sets v = 0, and returns v. -func (v *Element) Zero() *Element { - *v = *feZero - return v -} - -var feOne = &Element{1, 0, 0, 0, 0} - -// One sets v = 1, and returns v. -func (v *Element) One() *Element { - *v = *feOne - return v -} - -// reduce reduces v modulo 2^255 - 19 and returns it. -func (v *Element) reduce() *Element { - v.carryPropagate() - - // After the light reduction we now have a field element representation - // v < 2^255 + 2^13 * 19, but need v < 2^255 - 19. - - // If v >= 2^255 - 19, then v + 19 >= 2^255, which would overflow 2^255 - 1, - // generating a carry. That is, c will be 0 if v < 2^255 - 19, and 1 otherwise. - c := (v.l0 + 19) >> 51 - c = (v.l1 + c) >> 51 - c = (v.l2 + c) >> 51 - c = (v.l3 + c) >> 51 - c = (v.l4 + c) >> 51 - - // If v < 2^255 - 19 and c = 0, this will be a no-op. Otherwise, it's - // effectively applying the reduction identity to the carry. - v.l0 += 19 * c - - v.l1 += v.l0 >> 51 - v.l0 = v.l0 & maskLow51Bits - v.l2 += v.l1 >> 51 - v.l1 = v.l1 & maskLow51Bits - v.l3 += v.l2 >> 51 - v.l2 = v.l2 & maskLow51Bits - v.l4 += v.l3 >> 51 - v.l3 = v.l3 & maskLow51Bits - // no additional carry - v.l4 = v.l4 & maskLow51Bits - - return v -} - -// Add sets v = a + b, and returns v. -func (v *Element) Add(a, b *Element) *Element { - v.l0 = a.l0 + b.l0 - v.l1 = a.l1 + b.l1 - v.l2 = a.l2 + b.l2 - v.l3 = a.l3 + b.l3 - v.l4 = a.l4 + b.l4 - // Using the generic implementation here is actually faster than the - // assembly. Probably because the body of this function is so simple that - // the compiler can figure out better optimizations by inlining the carry - // propagation. TODO - return v.carryPropagateGeneric() -} - -// Subtract sets v = a - b, and returns v. -func (v *Element) Subtract(a, b *Element) *Element { - // We first add 2 * p, to guarantee the subtraction won't underflow, and - // then subtract b (which can be up to 2^255 + 2^13 * 19). - v.l0 = (a.l0 + 0xFFFFFFFFFFFDA) - b.l0 - v.l1 = (a.l1 + 0xFFFFFFFFFFFFE) - b.l1 - v.l2 = (a.l2 + 0xFFFFFFFFFFFFE) - b.l2 - v.l3 = (a.l3 + 0xFFFFFFFFFFFFE) - b.l3 - v.l4 = (a.l4 + 0xFFFFFFFFFFFFE) - b.l4 - return v.carryPropagate() -} - -// Negate sets v = -a, and returns v. -func (v *Element) Negate(a *Element) *Element { - return v.Subtract(feZero, a) -} - -// Invert sets v = 1/z mod p, and returns v. -// -// If z == 0, Invert returns v = 0. -func (v *Element) Invert(z *Element) *Element { - // Inversion is implemented as exponentiation with exponent p − 2. It uses the - // same sequence of 255 squarings and 11 multiplications as [Curve25519]. - var z2, z9, z11, z2_5_0, z2_10_0, z2_20_0, z2_50_0, z2_100_0, t Element - - z2.Square(z) // 2 - t.Square(&z2) // 4 - t.Square(&t) // 8 - z9.Multiply(&t, z) // 9 - z11.Multiply(&z9, &z2) // 11 - t.Square(&z11) // 22 - z2_5_0.Multiply(&t, &z9) // 31 = 2^5 - 2^0 - - t.Square(&z2_5_0) // 2^6 - 2^1 - for i := 0; i < 4; i++ { - t.Square(&t) // 2^10 - 2^5 - } - z2_10_0.Multiply(&t, &z2_5_0) // 2^10 - 2^0 - - t.Square(&z2_10_0) // 2^11 - 2^1 - for i := 0; i < 9; i++ { - t.Square(&t) // 2^20 - 2^10 - } - z2_20_0.Multiply(&t, &z2_10_0) // 2^20 - 2^0 - - t.Square(&z2_20_0) // 2^21 - 2^1 - for i := 0; i < 19; i++ { - t.Square(&t) // 2^40 - 2^20 - } - t.Multiply(&t, &z2_20_0) // 2^40 - 2^0 - - t.Square(&t) // 2^41 - 2^1 - for i := 0; i < 9; i++ { - t.Square(&t) // 2^50 - 2^10 - } - z2_50_0.Multiply(&t, &z2_10_0) // 2^50 - 2^0 - - t.Square(&z2_50_0) // 2^51 - 2^1 - for i := 0; i < 49; i++ { - t.Square(&t) // 2^100 - 2^50 - } - z2_100_0.Multiply(&t, &z2_50_0) // 2^100 - 2^0 - - t.Square(&z2_100_0) // 2^101 - 2^1 - for i := 0; i < 99; i++ { - t.Square(&t) // 2^200 - 2^100 - } - t.Multiply(&t, &z2_100_0) // 2^200 - 2^0 - - t.Square(&t) // 2^201 - 2^1 - for i := 0; i < 49; i++ { - t.Square(&t) // 2^250 - 2^50 - } - t.Multiply(&t, &z2_50_0) // 2^250 - 2^0 - - t.Square(&t) // 2^251 - 2^1 - t.Square(&t) // 2^252 - 2^2 - t.Square(&t) // 2^253 - 2^3 - t.Square(&t) // 2^254 - 2^4 - t.Square(&t) // 2^255 - 2^5 - - return v.Multiply(&t, &z11) // 2^255 - 21 -} - -// Set sets v = a, and returns v. -func (v *Element) Set(a *Element) *Element { - *v = *a - return v -} - -// SetBytes sets v to x, which must be a 32-byte little-endian encoding. -// -// Consistent with RFC 7748, the most significant bit (the high bit of the -// last byte) is ignored, and non-canonical values (2^255-19 through 2^255-1) -// are accepted. Note that this is laxer than specified by RFC 8032. -func (v *Element) SetBytes(x []byte) *Element { - if len(x) != 32 { - panic("edwards25519: invalid field element input size") - } - - // Bits 0:51 (bytes 0:8, bits 0:64, shift 0, mask 51). - v.l0 = binary.LittleEndian.Uint64(x[0:8]) - v.l0 &= maskLow51Bits - // Bits 51:102 (bytes 6:14, bits 48:112, shift 3, mask 51). - v.l1 = binary.LittleEndian.Uint64(x[6:14]) >> 3 - v.l1 &= maskLow51Bits - // Bits 102:153 (bytes 12:20, bits 96:160, shift 6, mask 51). - v.l2 = binary.LittleEndian.Uint64(x[12:20]) >> 6 - v.l2 &= maskLow51Bits - // Bits 153:204 (bytes 19:27, bits 152:216, shift 1, mask 51). - v.l3 = binary.LittleEndian.Uint64(x[19:27]) >> 1 - v.l3 &= maskLow51Bits - // Bits 204:251 (bytes 24:32, bits 192:256, shift 12, mask 51). - // Note: not bytes 25:33, shift 4, to avoid overread. - v.l4 = binary.LittleEndian.Uint64(x[24:32]) >> 12 - v.l4 &= maskLow51Bits - - return v -} - -// Bytes returns the canonical 32-byte little-endian encoding of v. -func (v *Element) Bytes() []byte { - // This function is outlined to make the allocations inline in the caller - // rather than happen on the heap. - var out [32]byte - return v.bytes(&out) -} - -func (v *Element) bytes(out *[32]byte) []byte { - t := *v - t.reduce() - - var buf [8]byte - for i, l := range [5]uint64{t.l0, t.l1, t.l2, t.l3, t.l4} { - bitsOffset := i * 51 - binary.LittleEndian.PutUint64(buf[:], l<= len(out) { - break - } - out[off] |= bb - } - } - - return out[:] -} - -// Equal returns 1 if v and u are equal, and 0 otherwise. -func (v *Element) Equal(u *Element) int { - sa, sv := u.Bytes(), v.Bytes() - return subtle.ConstantTimeCompare(sa, sv) -} - -// mask64Bits returns 0xffffffff if cond is 1, and 0 otherwise. -func mask64Bits(cond int) uint64 { return ^(uint64(cond) - 1) } - -// Select sets v to a if cond == 1, and to b if cond == 0. -func (v *Element) Select(a, b *Element, cond int) *Element { - m := mask64Bits(cond) - v.l0 = (m & a.l0) | (^m & b.l0) - v.l1 = (m & a.l1) | (^m & b.l1) - v.l2 = (m & a.l2) | (^m & b.l2) - v.l3 = (m & a.l3) | (^m & b.l3) - v.l4 = (m & a.l4) | (^m & b.l4) - return v -} - -// Swap swaps v and u if cond == 1 or leaves them unchanged if cond == 0, and returns v. -func (v *Element) Swap(u *Element, cond int) { - m := mask64Bits(cond) - t := m & (v.l0 ^ u.l0) - v.l0 ^= t - u.l0 ^= t - t = m & (v.l1 ^ u.l1) - v.l1 ^= t - u.l1 ^= t - t = m & (v.l2 ^ u.l2) - v.l2 ^= t - u.l2 ^= t - t = m & (v.l3 ^ u.l3) - v.l3 ^= t - u.l3 ^= t - t = m & (v.l4 ^ u.l4) - v.l4 ^= t - u.l4 ^= t -} - -// IsNegative returns 1 if v is negative, and 0 otherwise. -func (v *Element) IsNegative() int { - return int(v.Bytes()[0] & 1) -} - -// Absolute sets v to |u|, and returns v. -func (v *Element) Absolute(u *Element) *Element { - return v.Select(new(Element).Negate(u), u, u.IsNegative()) -} - -// Multiply sets v = x * y, and returns v. -func (v *Element) Multiply(x, y *Element) *Element { - feMul(v, x, y) - return v -} - -// Square sets v = x * x, and returns v. -func (v *Element) Square(x *Element) *Element { - feSquare(v, x) - return v -} - -// Mult32 sets v = x * y, and returns v. -func (v *Element) Mult32(x *Element, y uint32) *Element { - x0lo, x0hi := mul51(x.l0, y) - x1lo, x1hi := mul51(x.l1, y) - x2lo, x2hi := mul51(x.l2, y) - x3lo, x3hi := mul51(x.l3, y) - x4lo, x4hi := mul51(x.l4, y) - v.l0 = x0lo + 19*x4hi // carried over per the reduction identity - v.l1 = x1lo + x0hi - v.l2 = x2lo + x1hi - v.l3 = x3lo + x2hi - v.l4 = x4lo + x3hi - // The hi portions are going to be only 32 bits, plus any previous excess, - // so we can skip the carry propagation. - return v -} - -// mul51 returns lo + hi * 2⁵¹ = a * b. -func mul51(a uint64, b uint32) (lo uint64, hi uint64) { - mh, ml := bits.Mul64(a, uint64(b)) - lo = ml & maskLow51Bits - hi = (mh << 13) | (ml >> 51) - return -} - -// Pow22523 set v = x^((p-5)/8), and returns v. (p-5)/8 is 2^252-3. -func (v *Element) Pow22523(x *Element) *Element { - var t0, t1, t2 Element - - t0.Square(x) // x^2 - t1.Square(&t0) // x^4 - t1.Square(&t1) // x^8 - t1.Multiply(x, &t1) // x^9 - t0.Multiply(&t0, &t1) // x^11 - t0.Square(&t0) // x^22 - t0.Multiply(&t1, &t0) // x^31 - t1.Square(&t0) // x^62 - for i := 1; i < 5; i++ { // x^992 - t1.Square(&t1) - } - t0.Multiply(&t1, &t0) // x^1023 -> 1023 = 2^10 - 1 - t1.Square(&t0) // 2^11 - 2 - for i := 1; i < 10; i++ { // 2^20 - 2^10 - t1.Square(&t1) - } - t1.Multiply(&t1, &t0) // 2^20 - 1 - t2.Square(&t1) // 2^21 - 2 - for i := 1; i < 20; i++ { // 2^40 - 2^20 - t2.Square(&t2) - } - t1.Multiply(&t2, &t1) // 2^40 - 1 - t1.Square(&t1) // 2^41 - 2 - for i := 1; i < 10; i++ { // 2^50 - 2^10 - t1.Square(&t1) - } - t0.Multiply(&t1, &t0) // 2^50 - 1 - t1.Square(&t0) // 2^51 - 2 - for i := 1; i < 50; i++ { // 2^100 - 2^50 - t1.Square(&t1) - } - t1.Multiply(&t1, &t0) // 2^100 - 1 - t2.Square(&t1) // 2^101 - 2 - for i := 1; i < 100; i++ { // 2^200 - 2^100 - t2.Square(&t2) - } - t1.Multiply(&t2, &t1) // 2^200 - 1 - t1.Square(&t1) // 2^201 - 2 - for i := 1; i < 50; i++ { // 2^250 - 2^50 - t1.Square(&t1) - } - t0.Multiply(&t1, &t0) // 2^250 - 1 - t0.Square(&t0) // 2^251 - 2 - t0.Square(&t0) // 2^252 - 4 - return v.Multiply(&t0, x) // 2^252 - 3 -> x^(2^252-3) -} - -// sqrtM1 is 2^((p-1)/4), which squared is equal to -1 by Euler's Criterion. -var sqrtM1 = &Element{1718705420411056, 234908883556509, - 2233514472574048, 2117202627021982, 765476049583133} - -// SqrtRatio sets r to the non-negative square root of the ratio of u and v. -// -// If u/v is square, SqrtRatio returns r and 1. If u/v is not square, SqrtRatio -// sets r according to Section 4.3 of draft-irtf-cfrg-ristretto255-decaf448-00, -// and returns r and 0. -func (r *Element) SqrtRatio(u, v *Element) (rr *Element, wasSquare int) { - var a, b Element - - // r = (u * v3) * (u * v7)^((p-5)/8) - v2 := a.Square(v) - uv3 := b.Multiply(u, b.Multiply(v2, v)) - uv7 := a.Multiply(uv3, a.Square(v2)) - r.Multiply(uv3, r.Pow22523(uv7)) - - check := a.Multiply(v, a.Square(r)) // check = v * r^2 - - uNeg := b.Negate(u) - correctSignSqrt := check.Equal(u) - flippedSignSqrt := check.Equal(uNeg) - flippedSignSqrtI := check.Equal(uNeg.Multiply(uNeg, sqrtM1)) - - rPrime := b.Multiply(r, sqrtM1) // r_prime = SQRT_M1 * r - // r = CT_SELECT(r_prime IF flipped_sign_sqrt | flipped_sign_sqrt_i ELSE r) - r.Select(rPrime, r, flippedSignSqrt|flippedSignSqrtI) - - r.Absolute(r) // Choose the nonnegative square root. - return r, correctSignSqrt | flippedSignSqrt -} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go deleted file mode 100644 index 70c541692c..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go +++ /dev/null @@ -1,15 +0,0 @@ -// Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT. - -//go:build amd64 && gc && !purego - -package field - -// feMul sets out = a * b. It works like feMulGeneric. -// -//go:noescape -func feMul(out *Element, a *Element, b *Element) - -// feSquare sets out = a * a. It works like feSquareGeneric. -// -//go:noescape -func feSquare(out *Element, a *Element) diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.s b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.s deleted file mode 100644 index 60817acc41..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.s +++ /dev/null @@ -1,378 +0,0 @@ -// Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT. - -//go:build amd64 && gc && !purego - -#include "textflag.h" - -// func feMul(out *Element, a *Element, b *Element) -TEXT ·feMul(SB), NOSPLIT, $0-24 - MOVQ a+8(FP), CX - MOVQ b+16(FP), BX - - // r0 = a0×b0 - MOVQ (CX), AX - MULQ (BX) - MOVQ AX, DI - MOVQ DX, SI - - // r0 += 19×a1×b4 - MOVQ 8(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 32(BX) - ADDQ AX, DI - ADCQ DX, SI - - // r0 += 19×a2×b3 - MOVQ 16(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 24(BX) - ADDQ AX, DI - ADCQ DX, SI - - // r0 += 19×a3×b2 - MOVQ 24(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 16(BX) - ADDQ AX, DI - ADCQ DX, SI - - // r0 += 19×a4×b1 - MOVQ 32(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 8(BX) - ADDQ AX, DI - ADCQ DX, SI - - // r1 = a0×b1 - MOVQ (CX), AX - MULQ 8(BX) - MOVQ AX, R9 - MOVQ DX, R8 - - // r1 += a1×b0 - MOVQ 8(CX), AX - MULQ (BX) - ADDQ AX, R9 - ADCQ DX, R8 - - // r1 += 19×a2×b4 - MOVQ 16(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 32(BX) - ADDQ AX, R9 - ADCQ DX, R8 - - // r1 += 19×a3×b3 - MOVQ 24(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 24(BX) - ADDQ AX, R9 - ADCQ DX, R8 - - // r1 += 19×a4×b2 - MOVQ 32(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 16(BX) - ADDQ AX, R9 - ADCQ DX, R8 - - // r2 = a0×b2 - MOVQ (CX), AX - MULQ 16(BX) - MOVQ AX, R11 - MOVQ DX, R10 - - // r2 += a1×b1 - MOVQ 8(CX), AX - MULQ 8(BX) - ADDQ AX, R11 - ADCQ DX, R10 - - // r2 += a2×b0 - MOVQ 16(CX), AX - MULQ (BX) - ADDQ AX, R11 - ADCQ DX, R10 - - // r2 += 19×a3×b4 - MOVQ 24(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 32(BX) - ADDQ AX, R11 - ADCQ DX, R10 - - // r2 += 19×a4×b3 - MOVQ 32(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 24(BX) - ADDQ AX, R11 - ADCQ DX, R10 - - // r3 = a0×b3 - MOVQ (CX), AX - MULQ 24(BX) - MOVQ AX, R13 - MOVQ DX, R12 - - // r3 += a1×b2 - MOVQ 8(CX), AX - MULQ 16(BX) - ADDQ AX, R13 - ADCQ DX, R12 - - // r3 += a2×b1 - MOVQ 16(CX), AX - MULQ 8(BX) - ADDQ AX, R13 - ADCQ DX, R12 - - // r3 += a3×b0 - MOVQ 24(CX), AX - MULQ (BX) - ADDQ AX, R13 - ADCQ DX, R12 - - // r3 += 19×a4×b4 - MOVQ 32(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 32(BX) - ADDQ AX, R13 - ADCQ DX, R12 - - // r4 = a0×b4 - MOVQ (CX), AX - MULQ 32(BX) - MOVQ AX, R15 - MOVQ DX, R14 - - // r4 += a1×b3 - MOVQ 8(CX), AX - MULQ 24(BX) - ADDQ AX, R15 - ADCQ DX, R14 - - // r4 += a2×b2 - MOVQ 16(CX), AX - MULQ 16(BX) - ADDQ AX, R15 - ADCQ DX, R14 - - // r4 += a3×b1 - MOVQ 24(CX), AX - MULQ 8(BX) - ADDQ AX, R15 - ADCQ DX, R14 - - // r4 += a4×b0 - MOVQ 32(CX), AX - MULQ (BX) - ADDQ AX, R15 - ADCQ DX, R14 - - // First reduction chain - MOVQ $0x0007ffffffffffff, AX - SHLQ $0x0d, DI, SI - SHLQ $0x0d, R9, R8 - SHLQ $0x0d, R11, R10 - SHLQ $0x0d, R13, R12 - SHLQ $0x0d, R15, R14 - ANDQ AX, DI - IMUL3Q $0x13, R14, R14 - ADDQ R14, DI - ANDQ AX, R9 - ADDQ SI, R9 - ANDQ AX, R11 - ADDQ R8, R11 - ANDQ AX, R13 - ADDQ R10, R13 - ANDQ AX, R15 - ADDQ R12, R15 - - // Second reduction chain (carryPropagate) - MOVQ DI, SI - SHRQ $0x33, SI - MOVQ R9, R8 - SHRQ $0x33, R8 - MOVQ R11, R10 - SHRQ $0x33, R10 - MOVQ R13, R12 - SHRQ $0x33, R12 - MOVQ R15, R14 - SHRQ $0x33, R14 - ANDQ AX, DI - IMUL3Q $0x13, R14, R14 - ADDQ R14, DI - ANDQ AX, R9 - ADDQ SI, R9 - ANDQ AX, R11 - ADDQ R8, R11 - ANDQ AX, R13 - ADDQ R10, R13 - ANDQ AX, R15 - ADDQ R12, R15 - - // Store output - MOVQ out+0(FP), AX - MOVQ DI, (AX) - MOVQ R9, 8(AX) - MOVQ R11, 16(AX) - MOVQ R13, 24(AX) - MOVQ R15, 32(AX) - RET - -// func feSquare(out *Element, a *Element) -TEXT ·feSquare(SB), NOSPLIT, $0-16 - MOVQ a+8(FP), CX - - // r0 = l0×l0 - MOVQ (CX), AX - MULQ (CX) - MOVQ AX, SI - MOVQ DX, BX - - // r0 += 38×l1×l4 - MOVQ 8(CX), AX - IMUL3Q $0x26, AX, AX - MULQ 32(CX) - ADDQ AX, SI - ADCQ DX, BX - - // r0 += 38×l2×l3 - MOVQ 16(CX), AX - IMUL3Q $0x26, AX, AX - MULQ 24(CX) - ADDQ AX, SI - ADCQ DX, BX - - // r1 = 2×l0×l1 - MOVQ (CX), AX - SHLQ $0x01, AX - MULQ 8(CX) - MOVQ AX, R8 - MOVQ DX, DI - - // r1 += 38×l2×l4 - MOVQ 16(CX), AX - IMUL3Q $0x26, AX, AX - MULQ 32(CX) - ADDQ AX, R8 - ADCQ DX, DI - - // r1 += 19×l3×l3 - MOVQ 24(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 24(CX) - ADDQ AX, R8 - ADCQ DX, DI - - // r2 = 2×l0×l2 - MOVQ (CX), AX - SHLQ $0x01, AX - MULQ 16(CX) - MOVQ AX, R10 - MOVQ DX, R9 - - // r2 += l1×l1 - MOVQ 8(CX), AX - MULQ 8(CX) - ADDQ AX, R10 - ADCQ DX, R9 - - // r2 += 38×l3×l4 - MOVQ 24(CX), AX - IMUL3Q $0x26, AX, AX - MULQ 32(CX) - ADDQ AX, R10 - ADCQ DX, R9 - - // r3 = 2×l0×l3 - MOVQ (CX), AX - SHLQ $0x01, AX - MULQ 24(CX) - MOVQ AX, R12 - MOVQ DX, R11 - - // r3 += 2×l1×l2 - MOVQ 8(CX), AX - IMUL3Q $0x02, AX, AX - MULQ 16(CX) - ADDQ AX, R12 - ADCQ DX, R11 - - // r3 += 19×l4×l4 - MOVQ 32(CX), AX - IMUL3Q $0x13, AX, AX - MULQ 32(CX) - ADDQ AX, R12 - ADCQ DX, R11 - - // r4 = 2×l0×l4 - MOVQ (CX), AX - SHLQ $0x01, AX - MULQ 32(CX) - MOVQ AX, R14 - MOVQ DX, R13 - - // r4 += 2×l1×l3 - MOVQ 8(CX), AX - IMUL3Q $0x02, AX, AX - MULQ 24(CX) - ADDQ AX, R14 - ADCQ DX, R13 - - // r4 += l2×l2 - MOVQ 16(CX), AX - MULQ 16(CX) - ADDQ AX, R14 - ADCQ DX, R13 - - // First reduction chain - MOVQ $0x0007ffffffffffff, AX - SHLQ $0x0d, SI, BX - SHLQ $0x0d, R8, DI - SHLQ $0x0d, R10, R9 - SHLQ $0x0d, R12, R11 - SHLQ $0x0d, R14, R13 - ANDQ AX, SI - IMUL3Q $0x13, R13, R13 - ADDQ R13, SI - ANDQ AX, R8 - ADDQ BX, R8 - ANDQ AX, R10 - ADDQ DI, R10 - ANDQ AX, R12 - ADDQ R9, R12 - ANDQ AX, R14 - ADDQ R11, R14 - - // Second reduction chain (carryPropagate) - MOVQ SI, BX - SHRQ $0x33, BX - MOVQ R8, DI - SHRQ $0x33, DI - MOVQ R10, R9 - SHRQ $0x33, R9 - MOVQ R12, R11 - SHRQ $0x33, R11 - MOVQ R14, R13 - SHRQ $0x33, R13 - ANDQ AX, SI - IMUL3Q $0x13, R13, R13 - ADDQ R13, SI - ANDQ AX, R8 - ADDQ BX, R8 - ANDQ AX, R10 - ADDQ DI, R10 - ANDQ AX, R12 - ADDQ R9, R12 - ANDQ AX, R14 - ADDQ R11, R14 - - // Store output - MOVQ out+0(FP), AX - MOVQ SI, (AX) - MOVQ R8, 8(AX) - MOVQ R10, 16(AX) - MOVQ R12, 24(AX) - MOVQ R14, 32(AX) - RET diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go deleted file mode 100644 index 9da280d1d8..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright (c) 2019 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:build !amd64 || !gc || purego - -package field - -func feMul(v, x, y *Element) { feMulGeneric(v, x, y) } - -func feSquare(v, x *Element) { feSquareGeneric(v, x) } diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go deleted file mode 100644 index 075fe9b925..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright (c) 2020 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:build arm64 && gc && !purego - -package field - -//go:noescape -func carryPropagate(v *Element) - -func (v *Element) carryPropagate() *Element { - carryPropagate(v) - return v -} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.s b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.s deleted file mode 100644 index 3126a43419..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.s +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (c) 2020 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:build arm64 && gc && !purego - -#include "textflag.h" - -// carryPropagate works exactly like carryPropagateGeneric and uses the -// same AND, ADD, and LSR+MADD instructions emitted by the compiler, but -// avoids loading R0-R4 twice and uses LDP and STP. -// -// See https://golang.org/issues/43145 for the main compiler issue. -// -// func carryPropagate(v *Element) -TEXT ·carryPropagate(SB),NOFRAME|NOSPLIT,$0-8 - MOVD v+0(FP), R20 - - LDP 0(R20), (R0, R1) - LDP 16(R20), (R2, R3) - MOVD 32(R20), R4 - - AND $0x7ffffffffffff, R0, R10 - AND $0x7ffffffffffff, R1, R11 - AND $0x7ffffffffffff, R2, R12 - AND $0x7ffffffffffff, R3, R13 - AND $0x7ffffffffffff, R4, R14 - - ADD R0>>51, R11, R11 - ADD R1>>51, R12, R12 - ADD R2>>51, R13, R13 - ADD R3>>51, R14, R14 - // R4>>51 * 19 + R10 -> R10 - LSR $51, R4, R21 - MOVD $19, R22 - MADD R22, R10, R21, R10 - - STP (R10, R11), 0(R20) - STP (R12, R13), 16(R20) - MOVD R14, 32(R20) - - RET diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go deleted file mode 100644 index fc029ac12d..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright (c) 2021 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:build !arm64 || !gc || purego - -package field - -func (v *Element) carryPropagate() *Element { - return v.carryPropagateGeneric() -} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_generic.go b/vendor/golang.org/x/crypto/curve25519/internal/field/fe_generic.go deleted file mode 100644 index 2671217da5..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/fe_generic.go +++ /dev/null @@ -1,264 +0,0 @@ -// Copyright (c) 2017 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package field - -import "math/bits" - -// uint128 holds a 128-bit number as two 64-bit limbs, for use with the -// bits.Mul64 and bits.Add64 intrinsics. -type uint128 struct { - lo, hi uint64 -} - -// mul64 returns a * b. -func mul64(a, b uint64) uint128 { - hi, lo := bits.Mul64(a, b) - return uint128{lo, hi} -} - -// addMul64 returns v + a * b. -func addMul64(v uint128, a, b uint64) uint128 { - hi, lo := bits.Mul64(a, b) - lo, c := bits.Add64(lo, v.lo, 0) - hi, _ = bits.Add64(hi, v.hi, c) - return uint128{lo, hi} -} - -// shiftRightBy51 returns a >> 51. a is assumed to be at most 115 bits. -func shiftRightBy51(a uint128) uint64 { - return (a.hi << (64 - 51)) | (a.lo >> 51) -} - -func feMulGeneric(v, a, b *Element) { - a0 := a.l0 - a1 := a.l1 - a2 := a.l2 - a3 := a.l3 - a4 := a.l4 - - b0 := b.l0 - b1 := b.l1 - b2 := b.l2 - b3 := b.l3 - b4 := b.l4 - - // Limb multiplication works like pen-and-paper columnar multiplication, but - // with 51-bit limbs instead of digits. - // - // a4 a3 a2 a1 a0 x - // b4 b3 b2 b1 b0 = - // ------------------------ - // a4b0 a3b0 a2b0 a1b0 a0b0 + - // a4b1 a3b1 a2b1 a1b1 a0b1 + - // a4b2 a3b2 a2b2 a1b2 a0b2 + - // a4b3 a3b3 a2b3 a1b3 a0b3 + - // a4b4 a3b4 a2b4 a1b4 a0b4 = - // ---------------------------------------------- - // r8 r7 r6 r5 r4 r3 r2 r1 r0 - // - // We can then use the reduction identity (a * 2²⁵⁵ + b = a * 19 + b) to - // reduce the limbs that would overflow 255 bits. r5 * 2²⁵⁵ becomes 19 * r5, - // r6 * 2³⁰⁶ becomes 19 * r6 * 2⁵¹, etc. - // - // Reduction can be carried out simultaneously to multiplication. For - // example, we do not compute r5: whenever the result of a multiplication - // belongs to r5, like a1b4, we multiply it by 19 and add the result to r0. - // - // a4b0 a3b0 a2b0 a1b0 a0b0 + - // a3b1 a2b1 a1b1 a0b1 19×a4b1 + - // a2b2 a1b2 a0b2 19×a4b2 19×a3b2 + - // a1b3 a0b3 19×a4b3 19×a3b3 19×a2b3 + - // a0b4 19×a4b4 19×a3b4 19×a2b4 19×a1b4 = - // -------------------------------------- - // r4 r3 r2 r1 r0 - // - // Finally we add up the columns into wide, overlapping limbs. - - a1_19 := a1 * 19 - a2_19 := a2 * 19 - a3_19 := a3 * 19 - a4_19 := a4 * 19 - - // r0 = a0×b0 + 19×(a1×b4 + a2×b3 + a3×b2 + a4×b1) - r0 := mul64(a0, b0) - r0 = addMul64(r0, a1_19, b4) - r0 = addMul64(r0, a2_19, b3) - r0 = addMul64(r0, a3_19, b2) - r0 = addMul64(r0, a4_19, b1) - - // r1 = a0×b1 + a1×b0 + 19×(a2×b4 + a3×b3 + a4×b2) - r1 := mul64(a0, b1) - r1 = addMul64(r1, a1, b0) - r1 = addMul64(r1, a2_19, b4) - r1 = addMul64(r1, a3_19, b3) - r1 = addMul64(r1, a4_19, b2) - - // r2 = a0×b2 + a1×b1 + a2×b0 + 19×(a3×b4 + a4×b3) - r2 := mul64(a0, b2) - r2 = addMul64(r2, a1, b1) - r2 = addMul64(r2, a2, b0) - r2 = addMul64(r2, a3_19, b4) - r2 = addMul64(r2, a4_19, b3) - - // r3 = a0×b3 + a1×b2 + a2×b1 + a3×b0 + 19×a4×b4 - r3 := mul64(a0, b3) - r3 = addMul64(r3, a1, b2) - r3 = addMul64(r3, a2, b1) - r3 = addMul64(r3, a3, b0) - r3 = addMul64(r3, a4_19, b4) - - // r4 = a0×b4 + a1×b3 + a2×b2 + a3×b1 + a4×b0 - r4 := mul64(a0, b4) - r4 = addMul64(r4, a1, b3) - r4 = addMul64(r4, a2, b2) - r4 = addMul64(r4, a3, b1) - r4 = addMul64(r4, a4, b0) - - // After the multiplication, we need to reduce (carry) the five coefficients - // to obtain a result with limbs that are at most slightly larger than 2⁵¹, - // to respect the Element invariant. - // - // Overall, the reduction works the same as carryPropagate, except with - // wider inputs: we take the carry for each coefficient by shifting it right - // by 51, and add it to the limb above it. The top carry is multiplied by 19 - // according to the reduction identity and added to the lowest limb. - // - // The largest coefficient (r0) will be at most 111 bits, which guarantees - // that all carries are at most 111 - 51 = 60 bits, which fits in a uint64. - // - // r0 = a0×b0 + 19×(a1×b4 + a2×b3 + a3×b2 + a4×b1) - // r0 < 2⁵²×2⁵² + 19×(2⁵²×2⁵² + 2⁵²×2⁵² + 2⁵²×2⁵² + 2⁵²×2⁵²) - // r0 < (1 + 19 × 4) × 2⁵² × 2⁵² - // r0 < 2⁷ × 2⁵² × 2⁵² - // r0 < 2¹¹¹ - // - // Moreover, the top coefficient (r4) is at most 107 bits, so c4 is at most - // 56 bits, and c4 * 19 is at most 61 bits, which again fits in a uint64 and - // allows us to easily apply the reduction identity. - // - // r4 = a0×b4 + a1×b3 + a2×b2 + a3×b1 + a4×b0 - // r4 < 5 × 2⁵² × 2⁵² - // r4 < 2¹⁰⁷ - // - - c0 := shiftRightBy51(r0) - c1 := shiftRightBy51(r1) - c2 := shiftRightBy51(r2) - c3 := shiftRightBy51(r3) - c4 := shiftRightBy51(r4) - - rr0 := r0.lo&maskLow51Bits + c4*19 - rr1 := r1.lo&maskLow51Bits + c0 - rr2 := r2.lo&maskLow51Bits + c1 - rr3 := r3.lo&maskLow51Bits + c2 - rr4 := r4.lo&maskLow51Bits + c3 - - // Now all coefficients fit into 64-bit registers but are still too large to - // be passed around as a Element. We therefore do one last carry chain, - // where the carries will be small enough to fit in the wiggle room above 2⁵¹. - *v = Element{rr0, rr1, rr2, rr3, rr4} - v.carryPropagate() -} - -func feSquareGeneric(v, a *Element) { - l0 := a.l0 - l1 := a.l1 - l2 := a.l2 - l3 := a.l3 - l4 := a.l4 - - // Squaring works precisely like multiplication above, but thanks to its - // symmetry we get to group a few terms together. - // - // l4 l3 l2 l1 l0 x - // l4 l3 l2 l1 l0 = - // ------------------------ - // l4l0 l3l0 l2l0 l1l0 l0l0 + - // l4l1 l3l1 l2l1 l1l1 l0l1 + - // l4l2 l3l2 l2l2 l1l2 l0l2 + - // l4l3 l3l3 l2l3 l1l3 l0l3 + - // l4l4 l3l4 l2l4 l1l4 l0l4 = - // ---------------------------------------------- - // r8 r7 r6 r5 r4 r3 r2 r1 r0 - // - // l4l0 l3l0 l2l0 l1l0 l0l0 + - // l3l1 l2l1 l1l1 l0l1 19×l4l1 + - // l2l2 l1l2 l0l2 19×l4l2 19×l3l2 + - // l1l3 l0l3 19×l4l3 19×l3l3 19×l2l3 + - // l0l4 19×l4l4 19×l3l4 19×l2l4 19×l1l4 = - // -------------------------------------- - // r4 r3 r2 r1 r0 - // - // With precomputed 2×, 19×, and 2×19× terms, we can compute each limb with - // only three Mul64 and four Add64, instead of five and eight. - - l0_2 := l0 * 2 - l1_2 := l1 * 2 - - l1_38 := l1 * 38 - l2_38 := l2 * 38 - l3_38 := l3 * 38 - - l3_19 := l3 * 19 - l4_19 := l4 * 19 - - // r0 = l0×l0 + 19×(l1×l4 + l2×l3 + l3×l2 + l4×l1) = l0×l0 + 19×2×(l1×l4 + l2×l3) - r0 := mul64(l0, l0) - r0 = addMul64(r0, l1_38, l4) - r0 = addMul64(r0, l2_38, l3) - - // r1 = l0×l1 + l1×l0 + 19×(l2×l4 + l3×l3 + l4×l2) = 2×l0×l1 + 19×2×l2×l4 + 19×l3×l3 - r1 := mul64(l0_2, l1) - r1 = addMul64(r1, l2_38, l4) - r1 = addMul64(r1, l3_19, l3) - - // r2 = l0×l2 + l1×l1 + l2×l0 + 19×(l3×l4 + l4×l3) = 2×l0×l2 + l1×l1 + 19×2×l3×l4 - r2 := mul64(l0_2, l2) - r2 = addMul64(r2, l1, l1) - r2 = addMul64(r2, l3_38, l4) - - // r3 = l0×l3 + l1×l2 + l2×l1 + l3×l0 + 19×l4×l4 = 2×l0×l3 + 2×l1×l2 + 19×l4×l4 - r3 := mul64(l0_2, l3) - r3 = addMul64(r3, l1_2, l2) - r3 = addMul64(r3, l4_19, l4) - - // r4 = l0×l4 + l1×l3 + l2×l2 + l3×l1 + l4×l0 = 2×l0×l4 + 2×l1×l3 + l2×l2 - r4 := mul64(l0_2, l4) - r4 = addMul64(r4, l1_2, l3) - r4 = addMul64(r4, l2, l2) - - c0 := shiftRightBy51(r0) - c1 := shiftRightBy51(r1) - c2 := shiftRightBy51(r2) - c3 := shiftRightBy51(r3) - c4 := shiftRightBy51(r4) - - rr0 := r0.lo&maskLow51Bits + c4*19 - rr1 := r1.lo&maskLow51Bits + c0 - rr2 := r2.lo&maskLow51Bits + c1 - rr3 := r3.lo&maskLow51Bits + c2 - rr4 := r4.lo&maskLow51Bits + c3 - - *v = Element{rr0, rr1, rr2, rr3, rr4} - v.carryPropagate() -} - -// carryPropagateGeneric brings the limbs below 52 bits by applying the reduction -// identity (a * 2²⁵⁵ + b = a * 19 + b) to the l4 carry. TODO inline -func (v *Element) carryPropagateGeneric() *Element { - c0 := v.l0 >> 51 - c1 := v.l1 >> 51 - c2 := v.l2 >> 51 - c3 := v.l3 >> 51 - c4 := v.l4 >> 51 - - v.l0 = v.l0&maskLow51Bits + c4*19 - v.l1 = v.l1&maskLow51Bits + c0 - v.l2 = v.l2&maskLow51Bits + c1 - v.l3 = v.l3&maskLow51Bits + c2 - v.l4 = v.l4&maskLow51Bits + c3 - - return v -} diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint b/vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint deleted file mode 100644 index e3685f95ca..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint +++ /dev/null @@ -1 +0,0 @@ -b0c49ae9f59d233526f8934262c5bbbe14d4358d diff --git a/vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh b/vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh deleted file mode 100644 index 1ba22a8b4c..0000000000 --- a/vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh +++ /dev/null @@ -1,19 +0,0 @@ -#! /bin/bash -set -euo pipefail - -cd "$(git rev-parse --show-toplevel)" - -STD_PATH=src/crypto/ed25519/internal/edwards25519/field -LOCAL_PATH=curve25519/internal/field -LAST_SYNC_REF=$(cat $LOCAL_PATH/sync.checkpoint) - -git fetch https://go.googlesource.com/go master - -if git diff --quiet $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH; then - echo "No changes." -else - NEW_REF=$(git rev-parse FETCH_HEAD | tee $LOCAL_PATH/sync.checkpoint) - echo "Applying changes from $LAST_SYNC_REF to $NEW_REF..." - git diff $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH | \ - git apply -3 --directory=$LOCAL_PATH -fi diff --git a/vendor/golang.org/x/crypto/ed25519/ed25519.go b/vendor/golang.org/x/crypto/ed25519/ed25519.go index a7828345fc..59b3a95a7d 100644 --- a/vendor/golang.org/x/crypto/ed25519/ed25519.go +++ b/vendor/golang.org/x/crypto/ed25519/ed25519.go @@ -11,9 +11,7 @@ // operations with the same key more efficient. This package refers to the RFC // 8032 private key as the “seed”. // -// Beginning with Go 1.13, the functionality of this package was moved to the -// standard library as crypto/ed25519. This package only acts as a compatibility -// wrapper. +// This package is a wrapper around the standard library crypto/ed25519 package. package ed25519 import ( diff --git a/vendor/golang.org/x/crypto/hkdf/hkdf.go b/vendor/golang.org/x/crypto/hkdf/hkdf.go index f4ded5fee2..3bee66294e 100644 --- a/vendor/golang.org/x/crypto/hkdf/hkdf.go +++ b/vendor/golang.org/x/crypto/hkdf/hkdf.go @@ -8,7 +8,7 @@ // HKDF is a cryptographic key derivation function (KDF) with the goal of // expanding limited input keying material into one or more cryptographically // strong secret keys. -package hkdf // import "golang.org/x/crypto/hkdf" +package hkdf import ( "crypto/hmac" diff --git a/vendor/golang.org/x/crypto/md4/md4.go b/vendor/golang.org/x/crypto/md4/md4.go index d1911c2e86..7d9281e025 100644 --- a/vendor/golang.org/x/crypto/md4/md4.go +++ b/vendor/golang.org/x/crypto/md4/md4.go @@ -7,7 +7,7 @@ // Deprecated: MD4 is cryptographically broken and should only be used // where compatibility with legacy systems, not security, is the goal. Instead, // use a secure hash like SHA-256 (from crypto/sha256). -package md4 // import "golang.org/x/crypto/md4" +package md4 import ( "crypto" diff --git a/vendor/golang.org/x/crypto/nacl/box/box.go b/vendor/golang.org/x/crypto/nacl/box/box.go index 7f3b830ee2..357bdc773c 100644 --- a/vendor/golang.org/x/crypto/nacl/box/box.go +++ b/vendor/golang.org/x/crypto/nacl/box/box.go @@ -35,7 +35,7 @@ Anonymous sealing/opening is an extension of NaCl defined by and interoperable with libsodium: https://libsodium.gitbook.io/doc/public-key_cryptography/sealed_boxes. */ -package box // import "golang.org/x/crypto/nacl/box" +package box import ( cryptorand "crypto/rand" diff --git a/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go b/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go index f3c3242a04..1fe600ad03 100644 --- a/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go +++ b/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go @@ -32,7 +32,7 @@ chunk size. This package is interoperable with NaCl: https://nacl.cr.yp.to/secretbox.html. */ -package secretbox // import "golang.org/x/crypto/nacl/secretbox" +package secretbox import ( "golang.org/x/crypto/internal/alias" diff --git a/vendor/golang.org/x/crypto/openpgp/armor/armor.go b/vendor/golang.org/x/crypto/openpgp/armor/armor.go index 8907183ec0..e664d127cb 100644 --- a/vendor/golang.org/x/crypto/openpgp/armor/armor.go +++ b/vendor/golang.org/x/crypto/openpgp/armor/armor.go @@ -10,14 +10,15 @@ // for their specific task. If you are required to interoperate with OpenPGP // systems and need a maintained package, consider a community fork. // See https://golang.org/issue/44226. -package armor // import "golang.org/x/crypto/openpgp/armor" +package armor import ( "bufio" "bytes" "encoding/base64" - "golang.org/x/crypto/openpgp/errors" "io" + + "golang.org/x/crypto/openpgp/errors" ) // A Block represents an OpenPGP armored structure. diff --git a/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go b/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go index 743b35a120..f922bdbcaa 100644 --- a/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go +++ b/vendor/golang.org/x/crypto/openpgp/elgamal/elgamal.go @@ -16,7 +16,7 @@ // https://golang.org/issue/44226), and ElGamal in the OpenPGP ecosystem has // compatibility and security issues (see https://eprint.iacr.org/2021/923). // Moreover, this package doesn't protect against side-channel attacks. -package elgamal // import "golang.org/x/crypto/openpgp/elgamal" +package elgamal import ( "crypto/rand" diff --git a/vendor/golang.org/x/crypto/openpgp/errors/errors.go b/vendor/golang.org/x/crypto/openpgp/errors/errors.go index 1d7a0ea05a..a328749471 100644 --- a/vendor/golang.org/x/crypto/openpgp/errors/errors.go +++ b/vendor/golang.org/x/crypto/openpgp/errors/errors.go @@ -9,7 +9,7 @@ // for their specific task. If you are required to interoperate with OpenPGP // systems and need a maintained package, consider a community fork. // See https://golang.org/issue/44226. -package errors // import "golang.org/x/crypto/openpgp/errors" +package errors import ( "strconv" diff --git a/vendor/golang.org/x/crypto/openpgp/packet/packet.go b/vendor/golang.org/x/crypto/openpgp/packet/packet.go index 0a19794a8e..a84a1a214e 100644 --- a/vendor/golang.org/x/crypto/openpgp/packet/packet.go +++ b/vendor/golang.org/x/crypto/openpgp/packet/packet.go @@ -10,7 +10,7 @@ // for their specific task. If you are required to interoperate with OpenPGP // systems and need a maintained package, consider a community fork. // See https://golang.org/issue/44226. -package packet // import "golang.org/x/crypto/openpgp/packet" +package packet import ( "bufio" diff --git a/vendor/golang.org/x/crypto/openpgp/s2k/s2k.go b/vendor/golang.org/x/crypto/openpgp/s2k/s2k.go index f53244a1c7..fa1a919079 100644 --- a/vendor/golang.org/x/crypto/openpgp/s2k/s2k.go +++ b/vendor/golang.org/x/crypto/openpgp/s2k/s2k.go @@ -10,7 +10,7 @@ // for their specific task. If you are required to interoperate with OpenPGP // systems and need a maintained package, consider a community fork. // See https://golang.org/issue/44226. -package s2k // import "golang.org/x/crypto/openpgp/s2k" +package s2k import ( "crypto" diff --git a/vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go b/vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go index 904b57e01d..28cd99c7f3 100644 --- a/vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go +++ b/vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go @@ -16,7 +16,7 @@ Hash Functions SHA-1, SHA-224, SHA-256, SHA-384 and SHA-512 for HMAC. To choose, you can pass the `New` functions from the different SHA packages to pbkdf2.Key. */ -package pbkdf2 // import "golang.org/x/crypto/pbkdf2" +package pbkdf2 import ( "crypto/hmac" diff --git a/vendor/golang.org/x/crypto/poly1305/poly1305_compat.go b/vendor/golang.org/x/crypto/poly1305/poly1305_compat.go index dd975a32c9..cb9207f300 100644 --- a/vendor/golang.org/x/crypto/poly1305/poly1305_compat.go +++ b/vendor/golang.org/x/crypto/poly1305/poly1305_compat.go @@ -21,7 +21,7 @@ // For encryption, use the full ChaCha20-Poly1305 construction implemented by // golang.org/x/crypto/chacha20poly1305. For authentication, use a general // purpose MAC such as HMAC implemented by crypto/hmac. -package poly1305 // import "golang.org/x/crypto/poly1305" +package poly1305 import "golang.org/x/crypto/internal/poly1305" diff --git a/vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go b/vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go index 3fd05b2751..3685b34458 100644 --- a/vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go +++ b/vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go @@ -3,7 +3,7 @@ // license that can be found in the LICENSE file. // Package salsa provides low-level access to functions in the Salsa family. -package salsa // import "golang.org/x/crypto/salsa20/salsa" +package salsa import "math/bits" diff --git a/vendor/golang.org/x/crypto/scrypt/scrypt.go b/vendor/golang.org/x/crypto/scrypt/scrypt.go index c971a99fa6..76fa40fb20 100644 --- a/vendor/golang.org/x/crypto/scrypt/scrypt.go +++ b/vendor/golang.org/x/crypto/scrypt/scrypt.go @@ -5,7 +5,7 @@ // Package scrypt implements the scrypt key derivation function as defined in // Colin Percival's paper "Stronger Key Derivation via Sequential Memory-Hard // Functions" (https://www.tarsnap.com/scrypt/scrypt.pdf). -package scrypt // import "golang.org/x/crypto/scrypt" +package scrypt import ( "crypto/sha256" diff --git a/vendor/golang.org/x/crypto/ssh/agent/client.go b/vendor/golang.org/x/crypto/ssh/agent/client.go index fecba8eb38..106708d289 100644 --- a/vendor/golang.org/x/crypto/ssh/agent/client.go +++ b/vendor/golang.org/x/crypto/ssh/agent/client.go @@ -10,7 +10,7 @@ // References: // // [PROTOCOL.agent]: https://tools.ietf.org/html/draft-miller-ssh-agent-00 -package agent // import "golang.org/x/crypto/ssh/agent" +package agent import ( "bytes" diff --git a/vendor/golang.org/x/crypto/ssh/client_auth.go b/vendor/golang.org/x/crypto/ssh/client_auth.go index 9486c59862..b93961010d 100644 --- a/vendor/golang.org/x/crypto/ssh/client_auth.go +++ b/vendor/golang.org/x/crypto/ssh/client_auth.go @@ -71,6 +71,10 @@ func (c *connection) clientAuthenticate(config *ClientConfig) error { for auth := AuthMethod(new(noneAuth)); auth != nil; { ok, methods, err := auth.auth(sessionID, config.User, c.transport, config.Rand, extensions) if err != nil { + // On disconnect, return error immediately + if _, ok := err.(*disconnectMsg); ok { + return err + } // We return the error later if there is no other method left to // try. ok = authFailure diff --git a/vendor/golang.org/x/crypto/ssh/doc.go b/vendor/golang.org/x/crypto/ssh/doc.go index edbe63340d..f5d352fe3a 100644 --- a/vendor/golang.org/x/crypto/ssh/doc.go +++ b/vendor/golang.org/x/crypto/ssh/doc.go @@ -20,4 +20,4 @@ References: This package does not fall under the stability promise of the Go language itself, so its API may be changed when pressing needs arise. */ -package ssh // import "golang.org/x/crypto/ssh" +package ssh diff --git a/vendor/golang.org/x/sys/unix/mremap.go b/vendor/golang.org/x/sys/unix/mremap.go index fd45fe529d..3a5e776f89 100644 --- a/vendor/golang.org/x/sys/unix/mremap.go +++ b/vendor/golang.org/x/sys/unix/mremap.go @@ -50,3 +50,8 @@ func (m *mremapMmapper) Mremap(oldData []byte, newLength int, flags int) (data [ func Mremap(oldData []byte, newLength int, flags int) (data []byte, err error) { return mapper.Mremap(oldData, newLength, flags) } + +func MremapPtr(oldAddr unsafe.Pointer, oldSize uintptr, newAddr unsafe.Pointer, newSize uintptr, flags int) (ret unsafe.Pointer, err error) { + xaddr, err := mapper.mremap(uintptr(oldAddr), oldSize, newSize, flags, uintptr(newAddr)) + return unsafe.Pointer(xaddr), err +} diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go index 59542a897d..4cc7b00596 100644 --- a/vendor/golang.org/x/sys/unix/syscall_darwin.go +++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go @@ -542,6 +542,18 @@ func SysctlKinfoProcSlice(name string, args ...int) ([]KinfoProc, error) { } } +//sys pthread_chdir_np(path string) (err error) + +func PthreadChdir(path string) (err error) { + return pthread_chdir_np(path) +} + +//sys pthread_fchdir_np(fd int) (err error) + +func PthreadFchdir(fd int) (err error) { + return pthread_fchdir_np(fd) +} + //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) diff --git a/vendor/golang.org/x/sys/unix/syscall_unix.go b/vendor/golang.org/x/sys/unix/syscall_unix.go index 77081de8c7..4e92e5aa40 100644 --- a/vendor/golang.org/x/sys/unix/syscall_unix.go +++ b/vendor/golang.org/x/sys/unix/syscall_unix.go @@ -154,6 +154,15 @@ func Munmap(b []byte) (err error) { return mapper.Munmap(b) } +func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) { + xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset) + return unsafe.Pointer(xaddr), err +} + +func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) { + return mapper.munmap(uintptr(addr), length) +} + func Read(fd int, p []byte) (n int, err error) { n, err = read(fd, p) if raceenabled { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go index ccb02f240a..07642c308d 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go @@ -760,6 +760,39 @@ var libc_sysctl_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func pthread_chdir_np(path string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := syscall_syscall(libc_pthread_chdir_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pthread_chdir_np_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pthread_chdir_np pthread_chdir_np "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pthread_fchdir_np(fd int) (err error) { + _, _, e1 := syscall_syscall(libc_pthread_fchdir_np_trampoline_addr, uintptr(fd), 0, 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pthread_fchdir_np_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pthread_fchdir_np pthread_fchdir_np "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) if e1 != 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s index 8b8bb28402..923e08cb79 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s @@ -228,6 +228,16 @@ TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8 DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB) +TEXT libc_pthread_chdir_np_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pthread_chdir_np(SB) +GLOBL ·libc_pthread_chdir_np_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pthread_chdir_np_trampoline_addr(SB)/8, $libc_pthread_chdir_np_trampoline<>(SB) + +TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pthread_fchdir_np(SB) +GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_sendfile(SB) GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go index 1b40b997b5..7d73dda647 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go @@ -760,6 +760,39 @@ var libc_sysctl_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func pthread_chdir_np(path string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := syscall_syscall(libc_pthread_chdir_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pthread_chdir_np_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pthread_chdir_np pthread_chdir_np "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pthread_fchdir_np(fd int) (err error) { + _, _, e1 := syscall_syscall(libc_pthread_fchdir_np_trampoline_addr, uintptr(fd), 0, 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pthread_fchdir_np_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pthread_fchdir_np pthread_fchdir_np "/usr/lib/libSystem.B.dylib" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) if e1 != 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s index 08362c1ab7..057700111e 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s @@ -228,6 +228,16 @@ TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8 DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB) +TEXT libc_pthread_chdir_np_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pthread_chdir_np(SB) +GLOBL ·libc_pthread_chdir_np_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pthread_chdir_np_trampoline_addr(SB)/8, $libc_pthread_chdir_np_trampoline<>(SB) + +TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pthread_fchdir_np(SB) +GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_sendfile(SB) GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 diff --git a/vendor/golang.org/x/sys/windows/security_windows.go b/vendor/golang.org/x/sys/windows/security_windows.go index 6f7d2ac70a..97651b5bd0 100644 --- a/vendor/golang.org/x/sys/windows/security_windows.go +++ b/vendor/golang.org/x/sys/windows/security_windows.go @@ -894,7 +894,7 @@ type ACL struct { aclRevision byte sbz1 byte aclSize uint16 - aceCount uint16 + AceCount uint16 sbz2 uint16 } @@ -1087,6 +1087,27 @@ type EXPLICIT_ACCESS struct { Trustee TRUSTEE } +// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-ace_header +type ACE_HEADER struct { + AceType uint8 + AceFlags uint8 + AceSize uint16 +} + +// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-access_allowed_ace +type ACCESS_ALLOWED_ACE struct { + Header ACE_HEADER + Mask ACCESS_MASK + SidStart uint32 +} + +const ( + // Constants for AceType + // https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-ace_header + ACCESS_ALLOWED_ACE_TYPE = 0 + ACCESS_DENIED_ACE_TYPE = 1 +) + // This type is the union inside of TRUSTEE and must be created using one of the TrusteeValueFrom* functions. type TrusteeValue uintptr @@ -1158,6 +1179,7 @@ type OBJECTS_AND_NAME struct { //sys makeSelfRelativeSD(absoluteSD *SECURITY_DESCRIPTOR, selfRelativeSD *SECURITY_DESCRIPTOR, selfRelativeSDSize *uint32) (err error) = advapi32.MakeSelfRelativeSD //sys setEntriesInAcl(countExplicitEntries uint32, explicitEntries *EXPLICIT_ACCESS, oldACL *ACL, newACL **ACL) (ret error) = advapi32.SetEntriesInAclW +//sys GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (ret error) = advapi32.GetAce // Control returns the security descriptor control bits. func (sd *SECURITY_DESCRIPTOR) Control() (control SECURITY_DESCRIPTOR_CONTROL, revision uint32, err error) { diff --git a/vendor/golang.org/x/sys/windows/svc/service.go b/vendor/golang.org/x/sys/windows/svc/service.go index c96932d962..c4f74924dd 100644 --- a/vendor/golang.org/x/sys/windows/svc/service.go +++ b/vendor/golang.org/x/sys/windows/svc/service.go @@ -199,9 +199,8 @@ var ( ) func ctlHandler(ctl, evtype, evdata, context uintptr) uintptr { - s := (*service)(unsafe.Pointer(context)) e := ctlEvent{cmd: Cmd(ctl), eventType: uint32(evtype), eventData: evdata, context: 123456} // Set context to 123456 to test issue #25660. - s.c <- e + theService.c <- e return 0 } @@ -210,7 +209,7 @@ var theService service // This is, unfortunately, a global, which means only one // serviceMain is the entry point called by the service manager, registered earlier by // the call to StartServiceCtrlDispatcher. func serviceMain(argc uint32, argv **uint16) uintptr { - handle, err := windows.RegisterServiceCtrlHandlerEx(windows.StringToUTF16Ptr(theService.name), ctlHandlerCallback, uintptr(unsafe.Pointer(&theService))) + handle, err := windows.RegisterServiceCtrlHandlerEx(windows.StringToUTF16Ptr(theService.name), ctlHandlerCallback, 0) if sysErr, ok := err.(windows.Errno); ok { return uintptr(sysErr) } else if err != nil { diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go index 9f73df75b5..eba761018a 100644 --- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go +++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go @@ -91,6 +91,7 @@ var ( procEnumServicesStatusExW = modadvapi32.NewProc("EnumServicesStatusExW") procEqualSid = modadvapi32.NewProc("EqualSid") procFreeSid = modadvapi32.NewProc("FreeSid") + procGetAce = modadvapi32.NewProc("GetAce") procGetLengthSid = modadvapi32.NewProc("GetLengthSid") procGetNamedSecurityInfoW = modadvapi32.NewProc("GetNamedSecurityInfoW") procGetSecurityDescriptorControl = modadvapi32.NewProc("GetSecurityDescriptorControl") @@ -1224,6 +1225,14 @@ func setEntriesInAcl(countExplicitEntries uint32, explicitEntries *EXPLICIT_ACCE return } +func GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (ret error) { + r0, _, _ := syscall.Syscall(procGetAce.Addr(), 3, uintptr(unsafe.Pointer(acl)), uintptr(aceIndex), uintptr(unsafe.Pointer(pAce))) + if r0 == 0 { + ret = GetLastError() + } + return +} + func SetKernelObjectSecurity(handle Handle, securityInformation SECURITY_INFORMATION, securityDescriptor *SECURITY_DESCRIPTOR) (err error) { r1, _, e1 := syscall.Syscall(procSetKernelObjectSecurity.Addr(), 3, uintptr(handle), uintptr(securityInformation), uintptr(unsafe.Pointer(securityDescriptor))) if r1 == 0 { diff --git a/vendor/modules.txt b/vendor/modules.txt index 71c9939bff..007db8d733 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -545,11 +545,12 @@ github.com/moloch--/asciicast # github.com/moloch--/memmod v0.0.0-20230225130813-fd77d905589e ## explicit; go 1.17 github.com/moloch--/memmod -# github.com/ncruces/go-sqlite3 v0.15.0 +# github.com/ncruces/go-sqlite3 v0.17.1 ## explicit; go 1.21 github.com/ncruces/go-sqlite3 github.com/ncruces/go-sqlite3/driver github.com/ncruces/go-sqlite3/embed +github.com/ncruces/go-sqlite3/internal/alloc github.com/ncruces/go-sqlite3/internal/util github.com/ncruces/go-sqlite3/util/osutil github.com/ncruces/go-sqlite3/vfs @@ -704,7 +705,7 @@ github.com/tailscale/wireguard-go/tun # github.com/tcnksm/go-httpstat v0.2.0 ## explicit github.com/tcnksm/go-httpstat -# github.com/tetratelabs/wazero v1.7.2 +# github.com/tetratelabs/wazero v1.7.3 ## explicit; go 1.20 github.com/tetratelabs/wazero github.com/tetratelabs/wazero/api @@ -780,8 +781,8 @@ go4.org/mem # go4.org/netipx v0.0.0-20231129151722-fdeea329fbba ## explicit; go 1.18 go4.org/netipx -# golang.org/x/crypto v0.24.0 -## explicit; go 1.18 +# golang.org/x/crypto v0.25.0 +## explicit; go 1.20 golang.org/x/crypto/acme golang.org/x/crypto/acme/autocert golang.org/x/crypto/argon2 @@ -792,7 +793,6 @@ golang.org/x/crypto/cast5 golang.org/x/crypto/chacha20 golang.org/x/crypto/chacha20poly1305 golang.org/x/crypto/curve25519 -golang.org/x/crypto/curve25519/internal/field golang.org/x/crypto/ed25519 golang.org/x/crypto/hkdf golang.org/x/crypto/internal/alias @@ -847,7 +847,7 @@ golang.org/x/net/trace ## explicit; go 1.18 golang.org/x/sync/errgroup golang.org/x/sync/semaphore -# golang.org/x/sys v0.21.0 +# golang.org/x/sys v0.22.0 ## explicit; go 1.18 golang.org/x/sys/cpu golang.org/x/sys/plan9 @@ -856,7 +856,7 @@ golang.org/x/sys/windows golang.org/x/sys/windows/registry golang.org/x/sys/windows/svc golang.org/x/sys/windows/svc/mgr -# golang.org/x/term v0.21.0 +# golang.org/x/term v0.22.0 ## explicit; go 1.18 golang.org/x/term # golang.org/x/text v0.16.0

eq(Zh5Y)=ye3@Z?HksB$Osn& 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�u+H6NzrM9asvbMVF-b6NNed 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 z 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