wasm: Add Wasm TCG backend based on wasm64
Subsystems (2)
PATCH v2 1/35 meson: Add wasm64 support to the --cpu flag
In reply to Kohei Tokunagawasm64 target enables 64bit pointers using Emscripten's -sMEMORY64=1 flag[1]. This enables QEMU to run 64bit guests.
Although the configure script uses "uname -m" as the fallback value when "cpu" is empty, this can't be used for Emscripten which targets to Wasm. So, in wasm build, this commit fixes configure to require --cpu flag to be explicitly specified by the user.
[1] https://emscripten.org/docs/tools_reference/settings_reference.html#memory64
--- configure | 6 +++++- meson.build | 4 ++-- 2 files changed, 7 insertions(+), 3 deletions(-)
V2:
- This commit is under review in another patch series so please ignore it here.
configure +5 -1
@@ -365,7 +365,6 @@ elif check_define __APPLE__; then host_os=darwin elif check_define EMSCRIPTEN ; then host_os=emscripten - cpu=wasm32 cross_compile="yes" else # This is a fatal error, but don't report it yet, because we
@@ -425,6 +424,8 @@ elif check_define __aarch64__ ; then cpu="aarch64" elif check_define __loongarch64 ; then cpu="loongarch64" +elif check_define EMSCRIPTEN ; then + error_exit "wasm32 or wasm64 must be specified to the cpu flag" else # Using uname is really broken, but it is just a fallback for architectures # that are going to use TCI anyway
@@ -535,6 +536,9 @@ case "$cpu" in wasm32) CPU_CFLAGS="-m32" ;; + wasm64) + CPU_CFLAGS="-m64 -sMEMORY64=1" + ;; esac if test -n "$host_arch" && {
meson.build +2 -2
@@ -52,7 +52,7 @@ qapi_trace_events = [] bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin'] supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux', 'emscripten'] supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv32', 'riscv64', 'x86', 'x86_64', - 'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc64', 'wasm32'] + 'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc64', 'wasm32', 'wasm64'] cpu = host_machine.cpu_family()
@@ -916,7 +916,7 @@ if have_tcg if not get_option('tcg_interpreter') error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu)) endif - elif host_arch == 'wasm32' + elif host_arch == 'wasm32' or host_arch == 'wasm64' if not get_option('tcg_interpreter') error('WebAssembly host requires --enable-tcg-interpreter') endif
Signature · 1 line
2.43.0
PATCH v2 3/35 dockerfiles: Add support for wasm64 to the wasm Dockerfile
In reply to Kohei TokunagaThis commit fixes Dockerfile of the wasm build to support both of wasm32 and wasm64 build. Dockerfile takes the following build arguments and use these values for building dependencies.
- TARGET_CPU: target wasm arch (wasm32 or wasm64)
- WASM64_MEMORY64: target -sMEMORY64 mode (1 or 2)
---
MAINTAINERS | 2 +-
...2-cross.docker => emsdk-wasm-cross.docker} | 29 ++++++++++++++-----
2 files changed, 23 insertions(+), 8 deletions(-)
rename tests/docker/dockerfiles/{emsdk-wasm32-cross.docker => emsdk-wasm-cross.docker} (85%)V2:
- This commit is under review in another patch series so please ignore it here.
MAINTAINERS +1 -1
@@ -647,7 +647,7 @@ F: include/system/os-wasm.h F: os-wasm.c F: util/coroutine-wasm.c F: configs/meson/emscripten.txt -F: tests/docker/dockerfiles/emsdk-wasm32-cross.docker +F: tests/docker/dockerfiles/emsdk-wasm-cross.docker Alpha Machines --------------
tests/docker/dockerfiles/emsdk-wasm-cross.docker renamed from tests/docker/dockerfiles/emsdk-wasm32-cross.docker +22 -7
@@ -1,14 +1,17 @@ # syntax = docker/dockerfile:1.5 -ARG EMSDK_VERSION_QEMU=3.1.50 +ARG EMSDK_VERSION_QEMU=4.0.10 ARG ZLIB_VERSION=1.3.1 ARG GLIB_MINOR_VERSION=2.84 ARG GLIB_VERSION=${GLIB_MINOR_VERSION}.0 ARG PIXMAN_VERSION=0.44.2 -ARG FFI_VERSION=v3.4.7 +ARG FFI_VERSION=v3.5.2 ARG MESON_VERSION=1.5.0 +ARG TARGET_CPU=wasm32 +ARG WASM64_MEMORY64=0 -FROM emscripten/emsdk:$EMSDK_VERSION_QEMU AS build-base +FROM emscripten/emsdk:$EMSDK_VERSION_QEMU AS build-base-common +ARG TARGET_CPU ARG MESON_VERSION ENV TARGET=/builddeps/target ENV CPATH="$TARGET/include"
@@ -33,8 +36,8 @@ RUN <<EOF cat <<EOT > /cross.meson [host_machine] system = 'emscripten' -cpu_family = 'wasm32' -cpu = 'wasm32' +cpu_family = '${TARGET_CPU}' +cpu = '${TARGET_CPU}' endian = 'little' [binaries]
@@ -46,6 +49,16 @@ pkgconfig = ['pkg-config', '--static'] EOT EOF +FROM build-base-common AS build-base-wasm32 + +FROM build-base-common AS build-base-wasm64 +ARG WASM64_MEMORY64 +ENV CFLAGS="$CFLAGS -sMEMORY64=${WASM64_MEMORY64}" +ENV CXXFLAGS="$CXXFLAGS -sMEMORY64=${WASM64_MEMORY64}" +ENV LDFLAGS="$LDFLAGS -sMEMORY64=${WASM64_MEMORY64}" + +FROM build-base-${TARGET_CPU} AS build-base + FROM build-base AS zlib-dev ARG ZLIB_VERSION RUN mkdir -p /zlib
@@ -56,17 +69,19 @@ RUN emconfigure ./configure --prefix=$TARGET --static RUN emmake make install -j$(nproc) FROM build-base AS libffi-dev +ARG TARGET_CPU +ARG WASM64_MEMORY64 ARG FFI_VERSION RUN mkdir -p /libffi RUN git clone https://github.com/libffi/libffi /libffi WORKDIR /libffi RUN git checkout $FFI_VERSION RUN autoreconf -fiv -RUN emconfigure ./configure --host=wasm32-unknown-linux \ +RUN emconfigure ./configure --host=${TARGET_CPU}-unknown-linux \ --prefix=$TARGET --enable-static \ --disable-shared --disable-dependency-tracking \ --disable-builddir --disable-multi-os-directory \ - --disable-raw-api --disable-docs + --disable-raw-api --disable-docs WASM64_MEMORY64=${WASM64_MEMORY64} RUN emmake make install SUBDIRS='include' -j$(nproc) FROM build-base AS pixman-dev
Signature · 1 line
2.43.0
PATCH v2 7/35 tcg/wasm: Add constraint definitions
In reply to Kohei TokunagaThe Wasm backend integrates a forked TCI so its constraints are defined to remain compatible with TCI.
--- tcg/wasm/tcg-target-con-set.h | 19 +++++++++++++++++++ tcg/wasm/tcg-target-con-str.h | 14 ++++++++++++++ tcg/wasm/tcg-target.c.inc | 13 +++++++++++++ 3 files changed, 46 insertions(+) create mode 100644 tcg/wasm/tcg-target-con-set.h create mode 100644 tcg/wasm/tcg-target-con-str.h
tcg/wasm/tcg-target-con-set.h new file +19 -0
@@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Wasm target-specific constraint sets. +* +* Based on tci/tcg-target-con-set.h +* +* Copyright (c) 2021 Linaro +*/ + +/* +* C_On_Im(...) defines a constraint set with <n> outputs and <m> inputs. +* Each operand should be a sequence of constraint letters as defined by +* tcg-target-con-str.h; the constraint combination is inclusive or. +*/ +C_O0_I1(r) +C_O0_I2(r, r) +C_O1_I1(r, r) +C_O1_I2(r, r, r) +C_O1_I4(r, r, r, r, r)
tcg/wasm/tcg-target-con-str.h new file +14 -0
@@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Define Wasm target-specific operand constraints. +* +* Based on tci/tcg-target-con-str.h +* +* Copyright (c) 2021 Linaro +*/ + +/* +* Define constraint letters for register sets: +* REGS(letter, register_mask) +*/ +REGS ('r' ,MAKE_64BIT_MASK (0 ,TCG_TARGET_NB_REGS ))
tcg/wasm/tcg-target.c.inc +13 -0
@@ -75,3 +75,16 @@ static TCGReg tcg_target_call_oarg_reg(TCGCallReturnKind kind, int slot) tcg_debug_assert(slot >= 0 && slot < 128 / TCG_TARGET_REG_BITS); return TCG_REG_R0 + slot; } + +static TCGConstraintSetIndex +tcg_target_op_def(TCGOpcode op, TCGType type, unsigned flags) +{ + return C_NotImplemented; +} + +/* Test if a constant matches the constraint. */ +static bool tcg_target_const_match(int64_t val, int ct, + TCGType type, TCGCond cond, int vece) +{ + return ct & TCG_CT_CONST; +}
Signature · 1 line
2.43.0
v2 cover wasm: Add Wasm TCG backend based on wasm64
V2:
- Reorganized commits to implement the backend incrementally from a clean state.
- Removed the andc, orc, eqv, nand and nor operations to rely on default expansion.
- Removed the bswap operations to use default expansion.
- Removed the extract and deposit oprations to use default expansion.
- Updated the sextract to emit only when the corresponding Wasm instruction is available
- Removed the not operation to rely on default expansion.
- Fixed the neg implementation to "ret = 0 - arg"
- Added Wasm implementation of the mb operation using the atomic.fence instruction.
Note:
The first four commits are temporarily imported from a separated patch series which enables 64bit guests using wasm64 [2]. These commits are under review in that series and are included here only to allow subsequent patches to build. Please ignore them when reviewing this series.
V1:
This patch series adds a TCG backend for WebAssembly. Unlike eariler attempts [1], it is implemented using Emscripten's wasm64 target to support 64bit guests.
The first four commits are temporarily imported from a separated patch series which enables 64bit guests using wasm64 [2]. These commits are under review in that series and are included here only to allow subsequent patches to build. Please ignore them when reviewing this series.
# New TCG Backend for Browsers
A new TCG backend translates IR instructions into Wasm instructions and runs them using the browser's WebAssembly APIs (WebAssembly.Module and WebAssembly.instantiate). To minimize compilation overhead and avoid hitting the browser's limitation of the number of instances, this backend integrates a forked TCI. TBs run on TCI by default, with frequently executed TBs compiled into WebAssembly.
# 64bit guests support by wasm64
Support for 64bit guests is being reviewed in a separated patch series [2], which enables QEMU to use 64bit pointers by compiling with the --cpu=wasm64 flag. The Wasm TCG backend is based on this feature and also requires --cpu=wasm64.
QEMU compiled with --cpu=wasm64 runs on wasm64-capable engines. To support engines which don't support wasm64 (e.g. Safari), the Wasm backend can use the compatibility flag "--enable-wasm64-32bit-address-limit" also introduced in [2]. This flag enables 64bit pointers in the C code while Emscripten lowers the output binary to wasm32 and limits the maximum memory size to 4GB. As a result, the Wasm backend can run on wasm32 engiens while supporting 64bit guests.
Note: The flag was originally named --wasm64-32bit-address-limit but this patch series moved it from the configure script into meson_options.txt. To follow Meson's naming conventions, it was renamed to --enable-wasm64-32bit-address-limit.
# Overview of build process
To compile QEMU with Emscripten, the following dependencies are required. The emsdk-wasm-cross.docker environment includes all necessary components and can be used as the build environment:
- Emscripten SDK (emsdk) v4.0.10
- Libraries cross-compiled with Emscripten (please see also emsdk-wasm-cross.docker for build steps)
- GLib v2.84.0
- zlib v1.3.1
- libffi v3.5.2
- Pixman v0.44.2
The configure script supports --cpu=wasm64 flag to compile QEMU with 64bit pointer support.
emconfigure ./configure --cpu=wasm64 \
--static --disable-tools \
--target-list=x86_64-softmmuemmake make -j$(nproc)
If the output needs to run on wasm32 engines, use
"--enable-wasm64-32bit-address-limit" flag.
emconfigure ./configure --cpu=wasm64 --enable-wasm64-32bit-address-limit \
--static --disable-tools \
--target-list=x86_64-softmmuemmake make -j$(nproc)
Either of the above commands generates the following files:
- qemu-system-x86_64.js
- qemu-system-x86_64.wasm
Guest images can be packaged using Emscripten's file_packager.py tool. For example, if the images are stored in a directory named "pack", the following command packages them, allowing QEMU to access them through Emscripten's virtual filesystem:
/path/to/file_packager.py qemu-system-x86_64.data --preload pack > load.js
This process generates the following files:
- qemu-system-x86_64.data
- load.js
Emscripten allows passing arguments to the QEMU command via the Module object in JavaScript:
Module['arguments'] = [
'-nographic', '-m', '512M',
'-L', 'pack/',
'-drive', 'if=virtio,format=raw,file=pack/rootfs.bin',
'-kernel', 'pack/bzImage',
'-append', 'earlyprintk=ttyS0 console=ttyS0 root=/dev/vda loglevel=7',];
The sample repository [3] (tcgdev64 branch) provides a complete setup, including an HTML file that implements a terminal UI.
[1] https://patchew.org/QEMU/[email protected]/
[2] https://patchew.org/QEMU/[email protected]/
[3] https://github.com/ktock/qemu-wasm-sample/tree/tcgdev64
Kohei Tokunaga (35):
meson: Add wasm64 support to the --cpu flag
configure: Enable to propagate -sMEMORY64 flag to Emscripten
dockerfiles: Add support for wasm64 to the wasm Dockerfile .gitlab-ci.d: Add build tests for wasm64
tcg/wasm: Add tcg-target.h and tcg-target-reg-bits.h tcg/wasm: Add register-related definitions
tcg/wasm: Add constraint definitions
tcg/wasm: Add relocation callbacks
tcg/wasm: Add and/or/xor instructions
tcg/wasm: Add add/sub/mul instructions
tcg/wasm: Add shl/shr/sar instructions
tcg/wasm: Add setcond/negsetcond/movcond instructions tcg/wasm: Add sextract instruction
tcg/wasm: Add load and store instructions
tcg/wasm: Add mov/movi instructions
tcg/wasm: Add ext instructions
tcg/wasm: Add div/rem instructions
tcg/wasm: Add neg/ctpop instructions
tcg/wasm: Add rot/clz/ctz instructions
tcg/wasm: Add br/brcond instructions
tcg/wasm: Add exit_tb/goto_tb/goto_ptr instructions tcg/wasm: Add call instruction
tcg/wasm: Add qemu_ld/qemu_st instructions
tcg/wasm: Add mb instruction
tcg/wasm: Mark unimplemented instructions
tcg/wasm: Add initialization of fundamental registers tcg/wasm: Write wasm binary to TB
tcg/wasm: Implement instantiation of Wasm binary tcg/wasm: Allow switching coroutine from a helper tcg/wasm: Enable instantiation of TBs executed many times tcg/wasm: Enable TLB lookup
tcg/wasm: Add tcg_target_init function
meson.build: enable to build Wasm backend
meson.build: Propagate optimization flag for linking on Emscripten .gitlab-ci.d: build wasm backend in CI
.gitlab-ci.d/buildtest.yml | 26 +-
.gitlab-ci.d/container-cross.yml | 20 +-
.gitlab-ci.d/container-template.yml | 4 +-
MAINTAINERS | 9 +-
configure | 14 +-
include/accel/tcg/getpc.h | 2 +-
include/tcg/helper-info.h | 4 +-
include/tcg/tcg.h | 2 +-
meson.build | 16 +-
meson_options.txt | 3 +
scripts/meson-buildoptions.sh | 5 +
tcg/aarch64/tcg-target.c.inc | 11 +
tcg/arm/tcg-target.c.inc | 11 +
tcg/i386/tcg-target.c.inc | 11 +
tcg/loongarch64/tcg-target.c.inc | 11 +
tcg/meson.build | 5 +
tcg/mips/tcg-target.c.inc | 11 +
tcg/ppc/tcg-target.c.inc | 11 +
tcg/region.c | 10 +-
tcg/riscv/tcg-target.c.inc | 11 +
tcg/s390x/tcg-target.c.inc | 11 +
tcg/sparc64/tcg-target.c.inc | 11 +
tcg/tcg.c | 21 +-
tcg/tci/tcg-target.c.inc | 11 +
tcg/wasm.c | 855 +++++
tcg/wasm.h | 117 +
tcg/wasm/tcg-target-con-set.h | 19 +
tcg/wasm/tcg-target-con-str.h | 14 +
tcg/wasm/tcg-target-has.h | 14 +
tcg/wasm/tcg-target-mo.h | 20 +
tcg/wasm/tcg-target-opc.h.inc | 18 +
tcg/wasm/tcg-target-reg-bits.h | 11 +
tcg/wasm/tcg-target.c.inc | 2843 +++++++++++++++++
tcg/wasm/tcg-target.h | 61 +
...2-cross.docker => emsdk-wasm-cross.docker} | 29 +-
35 files changed, 4218 insertions(+), 34 deletions(-)
create mode 100644 tcg/wasm.c
create mode 100644 tcg/wasm.h
create mode 100644 tcg/wasm/tcg-target-con-set.h
create mode 100644 tcg/wasm/tcg-target-con-str.h
create mode 100644 tcg/wasm/tcg-target-has.h
create mode 100644 tcg/wasm/tcg-target-mo.h
create mode 100644 tcg/wasm/tcg-target-opc.h.inc
create mode 100644 tcg/wasm/tcg-target-reg-bits.h
create mode 100644 tcg/wasm/tcg-target.c.inc
create mode 100644 tcg/wasm/tcg-target.h
rename tests/docker/dockerfiles/{emsdk-wasm32-cross.docker => emsdk-wasm-cross.docker} (85%)Signature · 1 line
2.43.0
PATCH v2 6/35 tcg/wasm: Add register-related definitions
This commit adds the register allocation definitions and register names to the Wasm backend. As in TCI, call arguments are stored on the stack buffer and the return value is placed in the registers R0 and R1 when needed.
--- tcg/wasm/tcg-target.c.inc | 77 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 tcg/wasm/tcg-target.c.inc
V2:
- Although checkpatch.pl reports the following error in tcg/wasm/tcg-target.c.inc, this file is based on the TCI code so it is preserved as-is.
Quoted 3 lines
New file 'tcg/wasm/tcg-target.c.inc' must not have license boilerplate header text, only the SPDX-License-Identifier, unless this file was copied from existing code already having such text.
tcg/wasm/tcg-target.c.inc new file +77 -0
@@ -0,0 +1,77 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Tiny Code Generator for QEMU + * + * Copyright (c) 2009, 2011 Stefan Weil + * + * Based on tci/tcg-target.c.inc + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +static const int tcg_target_reg_alloc_order[] = { + TCG_REG_R2, + TCG_REG_R3, + TCG_REG_R4, + TCG_REG_R5, + TCG_REG_R6, + TCG_REG_R7, + TCG_REG_R8, + TCG_REG_R9, + TCG_REG_R10, + TCG_REG_R11, + TCG_REG_R12, + TCG_REG_R13, + TCG_REG_R14, + TCG_REG_R15, + /* 2 of these are call clobbered, so use them last. */ + TCG_REG_R1, + TCG_REG_R0, +}; + +#ifdef CONFIG_DEBUG_TCG +static const char *const tcg_target_reg_names[TCG_TARGET_NB_REGS] = { + "r00", + "r01", + "r02", + "r03", + "r04", + "r05", + "r06", + "r07", + "r08", + "r09", + "r10", + "r11", + "r12", + "r13", + "r14", + "r15", +}; +#endif + +/* No call arguments via registers. All will be stored on the "stack". */ +static const int tcg_target_call_iarg_regs[] = { }; + +static TCGReg tcg_target_call_oarg_reg(TCGCallReturnKind kind, int slot) +{ + tcg_debug_assert(kind == TCG_CALL_RET_NORMAL); + tcg_debug_assert(slot >= 0 && slot < 128 / TCG_TARGET_REG_BITS); + return TCG_REG_R0 + slot; +}
Signature · 1 line
2.43.0
PATCH v2 9/35 tcg/wasm: Add and/or/xor instructions
In reply to Kohei TokunagaThis commit adds support for generateing the and, or and xor operations. The generated Wasm codes will be instantiated and executed in the browser.
Browsers tipycally limit the number of active Wasm instances and the instantiating Wasm modules introduces overhead. As a result, instantiating TBs that are rarely called is undesirable. To address this, the Wasm backend relies on the a forked subset of the TCI interpreter (tcg_qemu_tb_exec_tci function in tcg/wasm.c) for executing such TBs.
The Wasm backend emits both Wasm and TCI instructions. TCI instructions are emitted to s->code_ptr, while the corresponding Wasm instructions are generated into a separate buffer allocated via tcg_malloc(). This buffer intends to be merged into the TB before tcg_gen_code returns.
In the Wasm code, each TCG variable is mapped to a 64bit Wasm variable. Execution works by first pushing the operands into the Wasm's stack using get instructions. The result is left on the stack and this can be assigned to a variable by popping it using a set instruction. The Wasm binary format is documented at [1].
Additionally, since the Wasm instuction's index operand must be LEB128-encoded, this commit introduces an encoder function implemented following [2].
[1] https://webassembly.github.io/spec/core/binary/index.html
[2] https://en.wikipedia.org/wiki/LEB128
--- MAINTAINERS | 1 + tcg/wasm.c | 66 ++++++++++++++++ tcg/wasm/tcg-target.c.inc | 160 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 227 insertions(+) create mode 100644 tcg/wasm.c
V2:
- This commit generates both Wasm and TCI instrucitons.
- Although checkpatch.pl reports the following error in tcg/wasm.c, this file is based on the TCI code so it is preserved as-is.
Quoted 3 lines
New file '
tcg/wasm.c' must not have license boilerplate header text, only the SPDX-License-Identifier, unless this file was copied from existing code already having such text.
MAINTAINERS +1 -0
@@ -4003,6 +4003,7 @@ WebAssembly TCG target M: Kohei Tokunaga <[email protected]> S: Maintained F: tcg/wasm/ +F: tcg/wasm.c Block drivers -------------
tcg/wasm.c new file +66 -0
66 lines not on this page · raw message
tcg/wasm/tcg-target.c.inc +160 -0
169 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 12/35 tcg/wasm: Add setcond/negsetcond/movcond instructions
In reply to Kohei TokunagaThese TCG instructions are implemented by using Wasm's if and else instructions. TCI instructions are also generated in the same way as the original TCI backend. Since support for TCG_COND_TSTEQ and TCG_COND_TSTNE is not yet implemented, TCG_TARGET_HAS_tst is set to 0.
--- tcg/wasm.c | 136 +++++++++++++++++++- tcg/wasm/tcg-target-has.h | 7 ++ tcg/wasm/tcg-target-opc.h.inc | 8 ++ tcg/wasm/tcg-target.c.inc | 230 ++++++++++++++++++++++++++++++++++ 4 files changed, 380 insertions(+), 1 deletion(-) create mode 100644 tcg/wasm/tcg-target-has.h create mode 100644 tcg/wasm/tcg-target-opc.h.inc
V2:
- This commit generates both Wasm and TCI instrucitons.
- Fixed the neg implementation in the negsetcond operation to "ret = 0 - arg"
tcg/wasm.c +135 -1
@@ -21,6 +21,12 @@#include "qemu/osdep.h" #include "tcg/tcg.h" +static void tci_args_rr (uint32_t insn,TCGReg *r0,TCGReg *r1) +{ + *r0 =extract32 (insn,8 ,4 ); + *r1 =extract32 (insn,12 ,4 ); +} +static void tci_args_rrr (uint32_t insn,TCGReg *r0,TCGReg *r1,TCGReg *r2) { *r0 =extract32 (insn,8 ,4 );
@@ -37,6 +43,110 @@ static void tci_args_rrbb(uint32_t insn, TCGReg *r0, TCGReg *r1, *i3 =extract32 (insn,22 ,6 ); } +static void tci_args_rrrc (uint32_t insn, +TCGReg *r0,TCGReg *r1,TCGReg *r2,TCGCond *c3) +{ + *r0 =extract32 (insn,8 ,4 ); + *r1 =extract32 (insn,12 ,4 ); + *r2 =extract32 (insn,16 ,4 ); + *c3 =extract32 (insn,20 ,4 ); +} + +static void tci_args_rrrrrc (uint32_t insn,TCGReg *r0,TCGReg *r1, +TCGReg *r2,TCGReg *r3,TCGReg *r4,TCGCond *c5) +{ + *r0 =extract32 (insn,8 ,4 ); + *r1 =extract32 (insn,12 ,4 ); + *r2 =extract32 (insn,16 ,4 ); + *r3 =extract32 (insn,20 ,4 ); + *r4 =extract32 (insn,24 ,4 ); + *c5 =extract32 (insn,28 ,4 ); +} + +static bool tci_compare32 (uint32_t u0,uint32_t u1,TCGCond condition) +{ +bool result = false; +int32_t i0 = u0; +int32_t i1 = u1; +switch (condition) { +case TCG_COND_EQ : + result = (u0 == u1); +break ; +case TCG_COND_NE : + result = (u0 != u1); +break ; +case TCG_COND_LT : + result = (i0 < i1); +break ; +case TCG_COND_GE : + result = (i0 >= i1); +break ; +case TCG_COND_LE : + result = (i0 <= i1); +break ; +case TCG_COND_GT : + result = (i0 > i1); +break ; +case TCG_COND_LTU : + result = (u0 < u1); +break ; +case TCG_COND_GEU : + result = (u0 >= u1); +break ; +case TCG_COND_LEU : + result = (u0 <= u1); +break ; +case TCG_COND_GTU : + result = (u0 > u1); +break ; +default : +g_assert_not_reached (); + } +return result; +} + +static bool tci_compare64 (uint64_t u0,uint64_t u1,TCGCond condition) +{ +bool result = false; +int64_t i0 = u0; +int64_t i1 = u1; +switch (condition) { +case TCG_COND_EQ : + result = (u0 == u1); +break ; +case TCG_COND_NE : + result = (u0 != u1); +break ; +case TCG_COND_LT : + result = (i0 < i1); +break ; +case TCG_COND_GE : + result = (i0 >= i1); +break ; +case TCG_COND_LE : + result = (i0 <= i1); +break ; +case TCG_COND_GT : + result = (i0 > i1); +break ; +case TCG_COND_LTU : + result = (u0 < u1); +break ; +case TCG_COND_GEU : + result = (u0 >= u1); +break ; +case TCG_COND_LEU : + result = (u0 <= u1); +break ; +case TCG_COND_GTU : + result = (u0 > u1); +break ; +default : +g_assert_not_reached (); + } +return result; +} +static uintptr_t tcg_qemu_tb_exec_tci (CPUArchState *env,const void *v_tb_ptr) {const uint32_t *tb_ptr = v_tb_ptr;
@@ -50,8 +160,10 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)for (;;) {uint32_t insn;TCGOpcode opc; -TCGReg r0, r1, r2; +TCGReg r0, r1, r2, r3, r4;uint8_t pos, len; +TCGCond condition; +uint32_t tmp32; insn = *tb_ptr++; opc =extract32 (insn,0 ,8 );
@@ -102,6 +214,28 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr) regs[r0] = ((tcg_target_long )regs[r1] >> (regs[r2] %TCG_TARGET_REG_BITS ));break ; +case INDEX_op_neg: +tci_args_rr (insn, &r0, &r1); + regs[r0] = -regs[r1]; +break ; +case INDEX_op_setcond: +tci_args_rrrc (insn, &r0, &r1, &r2, &condition); + regs[r0] =tci_compare64 (regs[r1], regs[r2], condition); +break ; +case INDEX_op_movcond: +tci_args_rrrrrc (insn, &r0, &r1, &r2, &r3, &r4, &condition); + tmp32 =tci_compare64 (regs[r1], regs[r2], condition); + regs[r0] = regs[tmp32 ? r3 : r4]; +break ; +case INDEX_op_tci_setcond32: +tci_args_rrrc (insn, &r0, &r1, &r2, &condition); + regs[r0] =tci_compare32 (regs[r1], regs[r2], condition); +break ; +case INDEX_op_tci_movcond32: +tci_args_rrrrrc (insn, &r0, &r1, &r2, &r3, &r4, &condition); + tmp32 =tci_compare32 (regs[r1], regs[r2], condition); + regs[r0] = regs[tmp32 ? r3 : r4]; +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target-has.h new file +7 -0
@@ -0,0 +1,7 @@ +/* SPDX-License-Identifier: MIT */ +#ifndef TCG_TARGET_HAS_H +#define TCG_TARGET_HAS_H + +#define TCG_TARGET_HAS_tst 0 + +#endif
tcg/wasm/tcg-target-opc.h.inc new file +8 -0
@@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Based on tci/tcg-target-opc.h.inc + * + * These opcodes for use between the tci generator and interpreter. + */ +DEF(tci_setcond32, 1, 2, 1, TCG_OPF_NOT_PRESENT) +DEF(tci_movcond32, 1, 2, 1, TCG_OPF_NOT_PRESENT)
tcg/wasm/tcg-target.c.inc +230 -0
281 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 17/35 tcg/wasm: Add div/rem instructions
In reply to Kohei TokunagaThe div and rem operations are implemented using the corresponding instructions in Wasm. TCI instructions are also generated in the same way as the original TCI backend.
--- tcg/wasm.c | 32 +++++++++++++++++ tcg/wasm/tcg-target-opc.h.inc | 4 +++ tcg/wasm/tcg-target.c.inc | 68 +++++++++++++++++++++++++++++++++++ 3 files changed, 104 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
tcg/wasm.c +32 -0
@@ -327,6 +327,38 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr) ptr = (void *)(regs[r1] + ofs); *(uint32_t *)ptr = regs[r0];break ; +case INDEX_op_divs: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = (int64_t )regs[r1] / (int64_t )regs[r2]; +break ; +case INDEX_op_divu: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = (uint64_t )regs[r1] / (uint64_t )regs[r2]; +break ; +case INDEX_op_rems: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = (int64_t )regs[r1] % (int64_t )regs[r2]; +break ; +case INDEX_op_remu: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = (uint64_t )regs[r1] % (uint64_t )regs[r2]; +break ; +case INDEX_op_tci_divs32: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = (int32_t )regs[r1] / (int32_t )regs[r2]; +break ; +case INDEX_op_tci_divu32: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = (uint32_t )regs[r1] / (uint32_t )regs[r2]; +break ; +case INDEX_op_tci_rems32: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = (int32_t )regs[r1] % (int32_t )regs[r2]; +break ; +case INDEX_op_tci_remu32: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = (uint32_t )regs[r1] % (uint32_t )regs[r2]; +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target-opc.h.inc +4 -0
@@ -8,3 +8,7 @@ DEF(tci_movi, 1, 0, 1, TCG_OPF_NOT_PRESENT) DEF(tci_movl, 1, 0, 1, TCG_OPF_NOT_PRESENT) DEF(tci_setcond32, 1, 2, 1, TCG_OPF_NOT_PRESENT) DEF(tci_movcond32, 1, 2, 1, TCG_OPF_NOT_PRESENT) +DEF(tci_divs32, 1, 2, 0, TCG_OPF_NOT_PRESENT) +DEF(tci_divu32, 1, 2, 0, TCG_OPF_NOT_PRESENT) +DEF(tci_rems32, 1, 2, 0, TCG_OPF_NOT_PRESENT) +DEF(tci_remu32, 1, 2, 0, TCG_OPF_NOT_PRESENT)
tcg/wasm/tcg-target.c.inc +68 -0
86 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 11/35 tcg/wasm: Add shl/shr/sar instructions
In reply to Kohei TokunagaThis commit implements the shl, shr and sar operations using Wasm instructions. Since the Wasm backend uses 64bit variables, right shifts on 32bit values extract the lower 32bit of the operand before shifting. TCI instructions are also generated in the same way as the original TCI backend.
--- tcg/wasm.c | 31 +++++++++++++ tcg/wasm/tcg-target.c.inc | 93 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 124 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
tcg/wasm.c +31 -0
@@ -28,6 +28,15 @@ static void tci_args_rrr(uint32_t insn, TCGReg *r0, TCGReg *r1, TCGReg *r2) *r2 =extract32 (insn,16 ,4 ); } +static void tci_args_rrbb (uint32_t insn,TCGReg *r0,TCGReg *r1, +uint8_t *i2,uint8_t *i3) +{ + *r0 =extract32 (insn,8 ,4 ); + *r1 =extract32 (insn,12 ,4 ); + *i2 =extract32 (insn,16 ,6 ); + *i3 =extract32 (insn,22 ,6 ); +} +static uintptr_t tcg_qemu_tb_exec_tci (CPUArchState *env,const void *v_tb_ptr) {const uint32_t *tb_ptr = v_tb_ptr;
@@ -42,6 +51,7 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)uint32_t insn;TCGOpcode opc;TCGReg r0, r1, r2; +uint8_t pos, len; insn = *tb_ptr++; opc =extract32 (insn,0 ,8 );
@@ -71,6 +81,27 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)tci_args_rrr (insn, &r0, &r1, &r2); regs[r0] = regs[r1] * regs[r2];break ; +case INDEX_op_extract: +tci_args_rrbb (insn, &r0, &r1, &pos, &len); + regs[r0] =extract64 (regs[r1], pos, len); +break ; +case INDEX_op_sextract: +tci_args_rrbb (insn, &r0, &r1, &pos, &len); + regs[r0] =sextract64 (regs[r1], pos, len); +break ; +case INDEX_op_shl: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = regs[r1] << (regs[r2] %TCG_TARGET_REG_BITS ); +break ; +case INDEX_op_shr: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = regs[r1] >> (regs[r2] %TCG_TARGET_REG_BITS ); +break ; +case INDEX_op_sar: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = ((tcg_target_long )regs[r1] + >> (regs[r2] %TCG_TARGET_REG_BITS )); +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target.c.inc +93 -0
123 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 18/35 tcg/wasm: Add neg/ctpop instructions
In reply to Kohei TokunagaThe neg/ctpop operations are implemented using the corresponding instructions in Wasm. TCI instructions are also generated in the same way as the original TCI backend.
The Wasm backend implements only TCG_TARGET_REG_BITS=64 so the ctpop instruction is generated only for 64bit operations, as declared in cset_ctpop. Therefore, this commit adds only the 64bit version of ctpop implementation.
--- tcg/wasm.c | 4 ++++ tcg/wasm/tcg-target.c.inc | 44 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
- Removed the not operation to rely on default expansion.
- Fixed the neg implementation to "ret = 0 - arg"
tcg/wasm.c +4 -0
@@ -359,6 +359,10 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)tci_args_rrr (insn, &r0, &r1, &r2); regs[r0] = (uint32_t )regs[r1] % (uint32_t )regs[r2];break ; +case INDEX_op_ctpop: +tci_args_rr (insn, &r0, &r1); + regs[r0] =ctpop64 (regs[r1]); +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target.c.inc +44 -0
62 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 22/35 tcg/wasm: Add call instruction
In reply to Kohei TokunagaTo call QEMU functions from a TB's Wasm module, the functions must be imported into the module.
Wasm's call instruction can invoke an imported function using a locally assigned function index. When a call TCG operation is generated, the Wasm backend assigns the ID (starting from 0) to the target function. The mapping between the function pointer and its assigned ID is recorded in a list of HelperInfo.
Since Wasm's call instruction requires arguments to be pushed onto the Wasm stack, the backend retrieves the function arguments from TCG's stack array and pushes them to the Wasm stack before the call. After the function returns, the result is retrieved from the Wasm stack and set in the corresponding TCG variable.
In the Emscripten build configured with !has_int128_type, a 128bit value is represented by the Int128 struct. Such values are passed to the function via pointer parameters and returned via a prepended pointer argument, as described in [1]. For this prepended buffer area, the module expects a pre-allocated Int128 buffer from the caller via ctx.buf128.
Helper functions expect the target of the return instruction via the GETPC macro (the tci_tb_ptr variable in TCI). However, unlike other architectures, Wasm doesn't have a register pointing to the return target. To emulate this behaviour, the Wasm module sets the instruction pointer to the corresponding TCI instruction (s->code_ptr) in tci_tb_ptr passed via the WasmContext.
TCI instructions are also generated in the same way as the original TCI backend.
--- tcg/wasm.c | 63 +++++++++++++ tcg/wasm.h | 10 +++ tcg/wasm/tcg-target.c.inc | 183 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 256 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
tcg/wasm.c +63 -0
@@ -21,6 +21,10 @@#include "qemu/osdep.h" #include "tcg/tcg.h" #include "tcg/tcg-ldst.h" +#include "tcg/helper-info.h" +#include <ffi.h> + +__threaduintptr_t tci_tb_ptr;static void tci_args_l (uint32_t insn,const void *tb_ptr,void **l0) {
@@ -33,6 +37,13 @@ static void tci_args_r(uint32_t insn, TCGReg *r0) *r0 =extract32 (insn,8 ,4 ); } +static void tci_args_nl (uint32_t insn,const void *tb_ptr, +uint8_t *n0,void **l1) +{ + *n0 =extract32 (insn,8 ,4 ); + *l1 =sextract32 (insn,12 ,20 ) + (void *)tb_ptr; +} +static void tci_args_rl (uint32_t insn,const void *tb_ptr,TCGReg *r0,void **l1) {
@@ -204,6 +215,58 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr) opc =extract32 (insn,0 ,8 );switch (opc) { +case INDEX_op_call: + { +void *call_slots[MAX_CALL_IARGS ]; +ffi_cif *cif; +void *func; +unsigned i, s, n; + +tci_args_nl (insn, tb_ptr, &len, &ptr); + func = ((void **)ptr)[0 ]; + cif = ((void **)ptr)[1 ]; + + n = cif->nargs; +for (i = s =0 ; i < n; ++i) { +ffi_type *t = cif->arg_types[i]; + call_slots[i] = &stack[s]; + s +=DIV_ROUND_UP (t->size,8 ); + } + +/* Helper functions may need to access the "return address" */ + tci_tb_ptr = (uintptr_t )tb_ptr; +ffi_call (cif, func, stack, call_slots); + } + +switch (len) { +case 0 :/* void */ +break ; +case 1 :/* uint32_t */ +/* +* The result winds up "left-aligned" in the stack[0] slot. +* Note that libffi has an odd special case in that it will +* always widen an integral result to ffi_arg. +*/ +if (sizeof (ffi_arg) ==8 ) { + regs[TCG_REG_R0 ] = (uint32_t )stack[0 ]; + }else { + regs[TCG_REG_R0 ] = *(uint32_t *)stack; + } +break ; +case 2 :/* uint64_t */ +/* +* For TCG_TARGET_REG_BITS == 32, the register pair +* must stay in host memory order. +*/ +memcpy (®s[TCG_REG_R0 ], stack,8 ); +break ; +case 3 :/* Int128 */ +memcpy (®s[TCG_REG_R0 ], stack,16 ); +break ; +default : +g_assert_not_reached (); + } +break ;case INDEX_op_and:tci_args_rrr (insn, &r0, &r1, &r2); regs[r0] = regs[r1] & regs[r2];
tcg/wasm.h +10 -0
@@ -10,6 +10,16 @@ struct WasmContext {* Pointer to the TB to be executed. */ void *tb_ptr; + +/* +* Pointer to the tci_tb_ptr variable. +*/ +void *tci_tb_ptr; + +/* +* Buffer to store 128bit return value on call. +*/ + void *buf128; };#endif
tcg/wasm/tcg-target.c.inc +183 -0
218 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 5/35 tcg/wasm: Add tcg-target.h and tcg-target-reg-bits.h
In reply to Kohei TokunagaThe Wasm backend targets wasm64 as the host so TCG_TARGET_REG_BITS is set to
64. Since WebAssembly instructions vary in size and can include single-byte instructions, TCG_TARGET_INSN_UNIT_SIZE is set to 1.
--- MAINTAINERS | 5 +++ tcg/wasm/tcg-target-reg-bits.h | 11 ++++++ tcg/wasm/tcg-target.h | 61 ++++++++++++++++++++++++++++++++++ 3 files changed, 77 insertions(+) create mode 100644 tcg/wasm/tcg-target-reg-bits.h create mode 100644 tcg/wasm/tcg-target.h
V2:
- Although checkpatch.pl reports the following error in tcg/wasm/tcg-target.h, this file is based on the TCI code so it is preserved as-is.
Quoted 3 lines
New file '
tcg/wasm/tcg-target.h' must not have license boilerplate header text, only the SPDX-License-Identifier, unless this file was copied from existing code already having such text.
MAINTAINERS +5 -0
@@ -3999,6 +3999,11 @@ F: tcg/tci/ F: tcg/tci.c F: disas/tci.c +WebAssembly TCG target +M: Kohei Tokunaga <[email protected]> +S: Maintained +F: tcg/wasm/ + Block drivers ------------- VMDK
tcg/wasm/tcg-target-reg-bits.h new file +11 -0
@@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: MIT */ + +#ifndef TCG_TARGET_REG_BITS_H +#define TCG_TARGET_REG_BITS_H + +#if UINTPTR_MAX !=UINT64_MAX +# error Unsupported pointer size for TCG target +#endif +#define TCG_TARGET_REG_BITS 64 + +#endif
tcg/wasm/tcg-target.h new file +61 -0
61 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 8/35 tcg/wasm: Add relocation callbacks
In reply to Kohei TokunagaRelocation callbacks are used for the TCI instructions to preserve the original logic of the TCI backend.
--- tcg/wasm/tcg-target.c.inc | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
tcg/wasm/tcg-target.c.inc +21 -0
@@ -88,3 +88,24 @@ static bool tcg_target_const_match(int64_t val, int ct, { return ct & TCG_CT_CONST; } + +static void tcg_out_nop_fill(tcg_insn_unit *p, int count) +{ + memset(p, 0, sizeof(*p) * count); +} + +static bool patch_reloc(tcg_insn_unit *code_ptr, int type, + intptr_t value, intptr_t addend) +{ + intptr_t diff = value - (intptr_t)(code_ptr + 4); + + tcg_debug_assert(addend == 0); + tcg_debug_assert(type == 20); + + if (diff == sextract32(diff, 0, type)) { + tcg_patch32(code_ptr, + deposit32(*(uint32_t *)code_ptr, 32 - type, type, diff)); + return true; + } + return false; +}
Signature · 1 line
2.43.0
PATCH v2 21/35 tcg/wasm: Add exit_tb/goto_tb/goto_ptr instructions
In reply to Kohei TokunagaIn the Wasm backend, each TB is compiled to a separeted Wasm module. Control transfer between TBs (i.e. from one Wasm module to another) is handled by the caller of the module.
The goto_tb and goto_ptr operations are implemented by returning control to the caller using the return instruction. The destination TB's pointer is passed to the caller via a shared WasmContext structure which is accessible from both the Wasm module and the caller. This WasmContext must be provided to the module as an argument.
If the destination TB is the current TB itself, there is no need to return control to the caller. Instead, execution can jump directly to the top of the loop within the TB.
The exit_tb operation sets the pointer in WasmContext to 0, indicating that there is no destination TB.
TCI instructions are also generated in the same way as the original TCI backend.
--- MAINTAINERS | 1 + tcg/wasm.c | 20 ++++++ tcg/wasm.h | 15 +++++ tcg/wasm/tcg-target.c.inc | 136 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 172 insertions(+) create mode 100644 tcg/wasm.h
V2:
- This commit generates both Wasm and TCI instrucitons.
MAINTAINERS +1 -0
@@ -4004,6 +4004,7 @@ M: Kohei Tokunaga <[email protected]> S: Maintained F: tcg/wasm/ F: tcg/wasm.c +F: tcg/wasm.h Block drivers -------------
tcg/wasm.c +20 -0
@@ -28,6 +28,11 @@ static void tci_args_l(uint32_t insn, const void *tb_ptr, void **l0) *l0 = diff ? (void *)tb_ptr + diff :NULL ; } +static void tci_args_r (uint32_t insn,TCGReg *r0) +{ + *r0 =extract32 (insn,8 ,4 ); +} +static void tci_args_rl (uint32_t insn,const void *tb_ptr,TCGReg *r0,void **l1) {
@@ -413,6 +418,21 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr) tb_ptr = ptr; }break ; +case INDEX_op_exit_tb: +tci_args_l (insn, tb_ptr, &ptr); +return (uintptr_t )ptr; +case INDEX_op_goto_tb: +tci_args_l (insn, tb_ptr, &ptr); + tb_ptr = *(void **)ptr; +break ; +case INDEX_op_goto_ptr: +tci_args_r (insn, &r0); + ptr = (void *)regs[r0]; +if (!ptr) { +return 0 ; + } + tb_ptr = ptr; +break ;default :g_assert_not_reached (); }
tcg/wasm.h new file +15 -0
@@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +#ifndef TCG_WASM_H +#define TCG_WASM_H + +/* +* WasmContext is a data shared among QEMU and wasm modules. +*/ +struct WasmContext { +/* +* Pointer to the TB to be executed. +*/ +void *tb_ptr; +}; + +#endif
tcg/wasm/tcg-target.c.inc +136 -0
172 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 2/35 configure: Enable to propagate -sMEMORY64 flag to Emscripten
In reply to Kohei TokunagaCurrently there are some engines that don't support wasm64 (e.g. unsupported on Safari[1]). To mitigate this issue, the configure script allows the user to use Emscripten's compatibility feature, "-sMEMORY64=2" flag[2].
Emscripten's "-sMEMORY64=2" flag still enables 64bit pointers in C code. But this flag lowers the output binary into wasm32, with limiting the maximum memory size to 4GB. So QEMU can run on wasm32 engines.
[1] https://webassembly.org/features/
[2] https://emscripten.org/docs/tools_reference/settings_reference.html#memory64
--- configure | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
V2:
- This commit is under review in another patch series so please ignore it here.
configure +11 -1
@@ -182,6 +182,10 @@ EXTRA_CXXFLAGS="" EXTRA_OBJCFLAGS="" EXTRA_LDFLAGS="" +# The value is propagated to Emscripten's "-sMEMORY64" flag. +# https://emscripten.org/docs/tools_reference/settings_reference.html#memory64 +wasm64_memory64=1 + # Default value for a variable defining feature "foo". # * foo="no" feature will only be used if --enable-foo arg is given # * foo="" feature will be searched for, and if found, will be used
@@ -239,6 +243,8 @@ for opt do ;; --without-default-features) default_feature="no" ;; + --wasm64-32bit-address-limit) wasm64_memory64="2" + ;; esac done
@@ -537,7 +543,7 @@ case "$cpu" in CPU_CFLAGS="-m32" ;; wasm64) - CPU_CFLAGS="-m64 -sMEMORY64=1" + CPU_CFLAGS="-m64 -sMEMORY64=$wasm64_memory64" ;; esac
@@ -795,6 +801,8 @@ for opt do ;; --disable-rust) rust=disabled ;; + --wasm64-32bit-address-limit) + ;; # everything else has the same name in configure and meson --*) meson_option_parse "$opt" "$optarg" ;;
@@ -920,6 +928,8 @@ Advanced options (experts only): --disable-containers don't use containers for cross-building --container-engine=TYPE which container engine to use [$container_engine] --gdb=GDB-path gdb to use for gdbstub tests [$gdb_bin] + --wasm64-32bit-address-limit Restrict wasm64 address space to 32-bit (default + is to use the whole 64-bit range). EOF meson_options_help cat << EOF
Signature · 1 line
2.43.0
PATCH v2 14/35 tcg/wasm: Add load and store instructions
In reply to Kohei TokunagaSince Wasm load and store instructions don't support negative offsets, address calculations are performed separately before the memory access.
When Emscripten's -sMEMORY64=2 is enabled, the address size must be 32bits. So this commit updates the build tools to propagate this flag to the C code via the WASM64_MEMORY64_2 macro. In this case, the emitted code casts pointers to 32bit before memory oprations.
Additionally, the declaration of "--wasm64-32bit-address-limit" flag has been moved from the configure script to meson.build. So the flag name is updated to "--enable-wasm64-32bit-address-limit" to follow Meson's naming conventions.
TCI instructions are also generated in the same way as the original TCI backend.
--- .gitlab-ci.d/buildtest.yml | 2 +- configure | 8 +- meson.build | 4 + meson_options.txt | 3 + scripts/meson-buildoptions.sh | 5 + tcg/wasm.c | 87 +++++++++++ tcg/wasm/tcg-target-mo.h | 20 +++ tcg/wasm/tcg-target-opc.h.inc | 2 + tcg/wasm/tcg-target.c.inc | 286 ++++++++++++++++++++++++++++++++++ 9 files changed, 411 insertions(+), 6 deletions(-) create mode 100644 tcg/wasm/tcg-target-mo.h
V2:
- This commit generates both Wasm and TCI instrucitons.
- Although checkpatch.pl reports an error "line over 90 characters" in scripts/meson-buildoptions.sh, the changes were automatically generated by meson-buildoptions.py and are preserved as-is.
.gitlab-ci.d/buildtest.yml +1 -1
@@ -812,4 +812,4 @@ build-wasm64-32bit: job: wasm64-32bit-emsdk-cross-container variables: IMAGE: emsdk-wasm64-32bit-cross - CONFIGURE_ARGS: --static --cpu=wasm64 --wasm64-32bit-address-limit --disable-tools --enable-debug --enable-tcg-interpreter + CONFIGURE_ARGS: --static --cpu=wasm64 --enable-wasm64-32bit-address-limit --disable-tools --enable-debug --enable-tcg-interpreter
configure +3 -5
@@ -243,7 +243,9 @@ for opt do ;; --without-default-features) default_feature="no" ;; - --wasm64-32bit-address-limit) wasm64_memory64="2" + --enable-wasm64-32bit-address-limit) wasm64_memory64="2" + ;; + --disable-wasm64-32bit-address-limit) wasm64_memory64="1" ;; esac done
@@ -801,8 +803,6 @@ for opt do ;; --disable-rust) rust=disabled ;; - --wasm64-32bit-address-limit) - ;; # everything else has the same name in configure and meson --*) meson_option_parse "$opt" "$optarg" ;;
@@ -928,8 +928,6 @@ Advanced options (experts only): --disable-containers don't use containers for cross-building --container-engine=TYPE which container engine to use [$container_engine] --gdb=GDB-path gdb to use for gdbstub tests [$gdb_bin] - --wasm64-32bit-address-limit Restrict wasm64 address space to 32-bit (default - is to use the whole 64-bit range). EOF meson_options_help cat << EOF
meson.build +4 -0
@@ -393,6 +393,10 @@ elif host_os == 'windows' if compiler.get_id() == 'clang' and compiler.get_linker_id() != 'ld.lld' error('On windows, you need to use lld with clang - use msys2 clang64/clangarm64 env') endif +elif host_os == 'emscripten' + if cpu == 'wasm64' and get_option('wasm64_32bit_address_limit') + qemu_common_flags += '-DWASM64_MEMORY64_2' + endif endif # Choose instruction set (currently x86-only)
meson_options.txt +3 -0
@@ -386,3 +386,6 @@ option('rust', type: 'feature', value: 'disabled', description: 'Rust support') option('strict_rust_lints', type: 'boolean', value: false, description: 'Enable stricter set of Rust warnings') + +option('wasm64_32bit_address_limit', type: 'boolean', value: false, + description: 'Restrict wasm64 address space to 32-bit (default is to use the whole 64-bit range).')
scripts/meson-buildoptions.sh +5 -0
@@ -56,6 +56,9 @@ meson_options_help() { printf "%s\n" ' dtrace/ftrace/log/nop/simple/syslog/ust)' printf "%s\n" ' --enable-tsan enable thread sanitizer' printf "%s\n" ' --enable-ubsan enable undefined behaviour sanitizer' + printf "%s\n" ' --enable-wasm64-32bit-address-limit' + printf "%s\n" ' Restrict wasm64 address space to 32-bit (default' + printf "%s\n" ' is to use the whole 64-bit range).' printf "%s\n" ' --firmwarepath=VALUES search PATH for firmware files [share/qemu-' printf "%s\n" ' firmware]' printf "%s\n" ' --iasl=VALUE Path to ACPI disassembler'
@@ -571,6 +574,8 @@ _meson_option_parse() { --disable-vte) printf "%s" -Dvte=disabled ;; --enable-vvfat) printf "%s" -Dvvfat=enabled ;; --disable-vvfat) printf "%s" -Dvvfat=disabled ;; + --enable-wasm64-32bit-address-limit) printf "%s" -Dwasm64_32bit_address_limit=true ;; + --disable-wasm64-32bit-address-limit) printf "%s" -Dwasm64_32bit_address_limit=false ;; --enable-werror) printf "%s" -Dwerror=true ;; --disable-werror) printf "%s" -Dwerror=false ;; --enable-whpx) printf "%s" -Dwhpx=enabled ;;
tcg/wasm.c +87 -0
120 lines not on this page · raw message
tcg/wasm/tcg-target-mo.h new file +20 -0
@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Define target-specific memory model +* +* Based on tci/tcg-target-mo.h +* +* Copyright (c) 2009, 2011 Stefan Weil +*/ + +#ifndef TCG_TARGET_MO_H +#define TCG_TARGET_MO_H + +/* +* We could notice __i386__ or __s390x__ and reduce the barriers depending +* on the host. But if you want performance, you use the normal backend. +* We prefer consistency across hosts on this. +*/ +#define TCG_TARGET_DEFAULT_MO 0 + +#endif
tcg/wasm/tcg-target-opc.h.inc +2 -0
@@ -4,5 +4,7 @@ * * These opcodes for use between the tci generator and interpreter. */ +DEF(tci_movi, 1, 0, 1, TCG_OPF_NOT_PRESENT) +DEF(tci_movl, 1, 0, 1, TCG_OPF_NOT_PRESENT) DEF(tci_setcond32, 1, 2, 1, TCG_OPF_NOT_PRESENT) DEF(tci_movcond32, 1, 2, 1, TCG_OPF_NOT_PRESENT)
tcg/wasm/tcg-target.c.inc +286 -0
316 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 16/35 tcg/wasm: Add ext instructions
In reply to Kohei TokunagaThe ext operations are implemented using the corresponding instructions in Wasm. TCI instructions are also generated in the same way as the original TCI backend.
--- tcg/wasm/tcg-target-has.h | 1 + tcg/wasm/tcg-target.c.inc | 79 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
- Moved tcg_wasm_out_extract to this commit for internal use to implement the ext instructions, although the extract operation itself is not generated in the Wasm backend.
tcg/wasm/tcg-target-has.h +1 -0
@@ -3,6 +3,7 @@#define TCG_TARGET_HAS_H #define TCG_TARGET_HAS_tst 0 +#define TCG_TARGET_HAS_extr_i64_i32 0#define TCG_TARGET_extract_valid (type, ofs, len) 0#define TCG_TARGET_sextract_valid (type, ofs, len) \
tcg/wasm/tcg-target.c.inc +79 -0
91 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 24/35 tcg/wasm: Add mb instruction
In reply to Kohei TokunagaThis commit generates the mb operation. In Wasm, it uses the atomic.fence instruction as the fence operator [1]. TCI instruction is also generated in the same way as the original TCI backend using smp_mb().
[1] https://webassembly.github.io/threads/core/syntax/instructions.html#atomic-memory-instructions
--- tcg/wasm.c | 4 ++++ tcg/wasm/tcg-target.c.inc | 19 +++++++++++++++++++ 2 files changed, 23 insertions(+)
V2:
- Added Wasm implementation of the mb operation using the atomic.fence instruction.
tcg/wasm.c +4 -0
@@ -566,6 +566,10 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr) taddr = regs[r1];tci_qemu_st (env, taddr, regs[r0], oi, tb_ptr);break ; +case INDEX_op_mb: +/* Ensure ordering for all kinds */ +smp_mb (); +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target.c.inc +19 -0
@@ -1116,6 +1116,11 @@ static void tcg_out_op_r(TCGContext *s, TCGOpcode op, TCGReg r0) tcg_out32(s, insn); } +static void tcg_out_op_v(TCGContext *s, TCGOpcode op) +{ + tcg_out32(s, (uint8_t)op); +} + static void tcg_out_op_ri(TCGContext *s, TCGOpcode op, TCGReg r0, int32_t i1) { tcg_insn_unit_tci insn = 0;
@@ -1931,6 +1936,20 @@ static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *l) g_assert_not_reached(); } +static void tcg_out_mb(TCGContext *s, unsigned a0) +{ + tcg_out_op_v(s, INDEX_op_mb); + + /* + * Wasm's threading proposal provides atomic.fence instruction as the fence + * operator. + * https://webassembly.github.io/threads/core/syntax/instructions.html#atomic-memory-instructions + */ + tcg_wasm_out8(s, 0xfe); + tcg_wasm_out8(s, 0x03); + tcg_wasm_out8(s, 0x00); +} + static void tcg_out_tb_start(TCGContext *s) { init_sub_buf();
Signature · 1 line
2.43.0
PATCH v2 13/35 tcg/wasm: Add sextract instruction
In reply to Kohei TokunagaThe sextract operation is genereted only when the corresponding Wasm instructions are available, as specified by TCG_TARGET_sextract_valid.
--- tcg/wasm/tcg-target-has.h | 5 +++++ tcg/wasm/tcg-target.c.inc | 42 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
- Removed the extract and deposit oprations to use default expansion.
- Updated the sextract to emit only when the corresponding Wasm instruction is available
tcg/wasm/tcg-target-has.h +5 -0
@@ -4,4 +4,9 @@#define TCG_TARGET_HAS_tst 0 +#define TCG_TARGET_extract_valid (type, ofs, len) 0 +#define TCG_TARGET_sextract_valid (type, ofs, len) \ + ((ofs == 0) && ((len == 8) || (len == 16) || (len == 32))) +#define TCG_TARGET_deposit_valid (type, ofs, len) 0 +#endif
tcg/wasm/tcg-target.c.inc +42 -0
61 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 4/35 .gitlab-ci.d: Add build tests for wasm64
In reply to Kohei TokunagaThe wasm builds are tested for 3 targets: wasm32, wasm64(-sMEMORY64=1) and wasm64(-sMEMORY64=2). The CI builds the containers using the same Dockerfile (emsdk-wasm-cross.docker) with different build args.
--- .gitlab-ci.d/buildtest.yml | 26 ++++++++++++++++++++++---- .gitlab-ci.d/container-cross.yml | 20 ++++++++++++++++++-- .gitlab-ci.d/container-template.yml | 4 +++- 3 files changed, 43 insertions(+), 7 deletions(-)
V2:
- This commit is under review in another patch series so please ignore it here.
.gitlab-ci.d/buildtest.yml +22 -4
@@ -787,11 +787,29 @@ coverity: # Always manual on forks even if $QEMU_CI == "2" - when: manual -build-wasm: +build-wasm32-32bit: extends: .wasm_build_job_template timeout: 2h needs: - job: wasm-emsdk-cross-container + job: wasm32-32bit-emsdk-cross-container variables: - IMAGE: emsdk-wasm32-cross - CONFIGURE_ARGS: --static --disable-tools --enable-debug --enable-tcg-interpreter + IMAGE: emsdk-wasm32-32bit-cross + CONFIGURE_ARGS: --static --cpu=wasm32 --disable-tools --enable-debug --enable-tcg-interpreter + +build-wasm64-64bit: + extends: .wasm_build_job_template + timeout: 2h + needs: + job: wasm64-64bit-emsdk-cross-container + variables: + IMAGE: emsdk-wasm64-64bit-cross + CONFIGURE_ARGS: --static --cpu=wasm64 --disable-tools --enable-debug --enable-tcg-interpreter + +build-wasm64-32bit: + extends: .wasm_build_job_template + timeout: 2h + needs: + job: wasm64-32bit-emsdk-cross-container + variables: + IMAGE: emsdk-wasm64-32bit-cross + CONFIGURE_ARGS: --static --cpu=wasm64 --wasm64-32bit-address-limit --disable-tools --enable-debug --enable-tcg-interpreter
.gitlab-ci.d/container-cross.yml +18 -2
@@ -92,7 +92,23 @@ win64-fedora-cross-container: variables: NAME: fedora-win64-cross -wasm-emsdk-cross-container: +wasm32-32bit-emsdk-cross-container: extends: .container_job_template variables: - NAME: emsdk-wasm32-cross + NAME: emsdk-wasm32-32bit-cross + BUILD_ARGS: --build-arg TARGET_CPU=wasm32 + DOCKERFILE: emsdk-wasm-cross + +wasm64-64bit-emsdk-cross-container: + extends: .container_job_template + variables: + NAME: emsdk-wasm64-64bit-cross + BUILD_ARGS: --build-arg TARGET_CPU=wasm64 --build-arg WASM64_MEMORY64=1 + DOCKERFILE: emsdk-wasm-cross + +wasm64-32bit-emsdk-cross-container: + extends: .container_job_template + variables: + NAME: emsdk-wasm64-32bit-cross + BUILD_ARGS: --build-arg TARGET_CPU=wasm64 --build-arg WASM64_MEMORY64=2 + DOCKERFILE: emsdk-wasm-cross
.gitlab-ci.d/container-template.yml +3 -1
@@ -10,12 +10,14 @@ - export COMMON_TAG="$CI_REGISTRY/qemu-project/qemu/qemu/$NAME:latest" - docker login $CI_REGISTRY -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" - until docker info; do sleep 1; done + - export DOCKERFILE_NAME=${DOCKERFILE:-$NAME} script: - echo "TAG:$TAG" - echo "COMMON_TAG:$COMMON_TAG" - docker build --tag "$TAG" --cache-from "$TAG" --cache-from "$COMMON_TAG" --build-arg BUILDKIT_INLINE_CACHE=1 - -f "tests/docker/dockerfiles/$NAME.docker" "." + $BUILD_ARGS + -f "tests/docker/dockerfiles/$DOCKERFILE_NAME.docker" "." - docker push "$TAG" after_script: - docker logout
Signature · 1 line
2.43.0
PATCH v2 20/35 tcg/wasm: Add br/brcond instructions
In reply to Kohei TokunagaWasm does not support direct jumps to arbitrary code addresses, so br and brcond are implemented using Wasm's control flow instructions.
As illustrated in the pseudo-code below, each TB wraps Wasm instructions inside a large loop. Each set of codes separated by TCG labels is placed inside an "if" block. Br is implemented by breaking out of the current block and entering the target block:
loop
if
... code after the first label
end
if
... code after the second label
end
...
end
Each block is assigned an unique integer ID. The br implementation sets the destination block's ID in BLOCK_IDX Wasm variable and breaks from the current if block. As control flow continues, each if block checks whether the BLOCK_IDX matches its own ID. If so, execution resumes within that block.
The tcg_out_tb_start function generates the start of the global loop and the first if block. To properly close these blocks, this commit also introduces a new callback tcg_out_tb_end which emits the "end" instructions for the final if block and the loop.
Another new callback tcg_out_label_cb is used to emit block boundaries, specifically the end of the previous block and the if of the next block, at label positions. It also records the mapping between label IDs and block IDs in a LabelInfo list.
Since the block ID for a label might not be known when a br instruction is generated, a placeholder is emitted instead. These placeholders are tracked in a BlockPlaceholder list and resolved later using LabelInfo.
TCI instructions are also generated in the same way as the original TCI backend.
--- tcg/aarch64/tcg-target.c.inc | 11 ++ tcg/arm/tcg-target.c.inc | 11 ++ tcg/i386/tcg-target.c.inc | 11 ++ tcg/loongarch64/tcg-target.c.inc | 11 ++ tcg/mips/tcg-target.c.inc | 11 ++ tcg/ppc/tcg-target.c.inc | 11 ++ tcg/riscv/tcg-target.c.inc | 11 ++ tcg/s390x/tcg-target.c.inc | 11 ++ tcg/sparc64/tcg-target.c.inc | 11 ++ tcg/tcg.c | 7 ++ tcg/tci/tcg-target.c.inc | 11 ++ tcg/wasm.c | 16 +++ tcg/wasm/tcg-target.c.inc | 196 +++++++++++++++++++++++++++++++ 13 files changed, 329 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
tcg/aarch64/tcg-target.c.inc +11 -0
@@ -3514,6 +3514,17 @@ static void tcg_out_tb_start(TCGContext *s) tcg_out_bti(s, BTI_J); } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + static void tcg_out_nop_fill(tcg_insn_unit *p, int count) { int i;
tcg/arm/tcg-target.c.inc +11 -0
@@ -3441,6 +3441,17 @@ static void tcg_out_tb_start(TCGContext *s) /* nothing to do */ } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + typedef struct { DebugFrameHeader h; uint8_t fde_def_cfa[4];
tcg/i386/tcg-target.c.inc +11 -0
@@ -4759,6 +4759,17 @@ static void tcg_out_tb_start(TCGContext *s) /* nothing to do */ } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + static void tcg_out_nop_fill(tcg_insn_unit *p, int count) { memset(p, 0x90, count);
tcg/loongarch64/tcg-target.c.inc +11 -0
@@ -2658,6 +2658,17 @@ static void tcg_out_tb_start(TCGContext *s) /* nothing to do */ } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + static void tcg_out_nop_fill(tcg_insn_unit *p, int count) { for (int i = 0; i < count; ++i) {
tcg/mips/tcg-target.c.inc +11 -0
@@ -2745,6 +2745,17 @@ static void tcg_out_tb_start(TCGContext *s) /* nothing to do */ } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + static void tcg_target_init(TCGContext *s) { tcg_target_detect_isa();
tcg/ppc/tcg-target.c.inc +11 -0
@@ -2859,6 +2859,17 @@ static void tcg_out_tb_start(TCGContext *s) } } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + static void tcg_out_exit_tb(TCGContext *s, uintptr_t arg) { tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R3, arg);
tcg/riscv/tcg-target.c.inc +11 -0
@@ -2983,6 +2983,17 @@ static void tcg_out_tb_start(TCGContext *s) init_setting_vtype(s); } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + static bool vtype_check(unsigned vtype) { unsigned long tmp;
tcg/s390x/tcg-target.c.inc +11 -0
@@ -3830,6 +3830,17 @@ static void tcg_out_tb_start(TCGContext *s) /* nothing to do */ } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + static void tcg_out_nop_fill(tcg_insn_unit *p, int count) { memset(p, 0x07, count * sizeof(tcg_insn_unit));
tcg/sparc64/tcg-target.c.inc +11 -0
@@ -1017,6 +1017,17 @@ static void tcg_out_tb_start(TCGContext *s) /* nothing to do */ } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + static void tcg_out_nop_fill(tcg_insn_unit *p, int count) { int i;
tcg/tcg.c +7 -0
@@ -116,6 +116,7 @@ static void tcg_register_jit_int(const void *buf, size_t size,/* Forward declarations for functions declared and used in tcg-target.c.inc. */ static void tcg_out_tb_start (TCGContext *s); +static int tcg_out_tb_end (TCGContext *s);static void tcg_out_ld (TCGContext *s,TCGType type,TCGReg ret,TCGReg arg1,intptr_t arg2);static bool tcg_out_mov (TCGContext *s,TCGType type,TCGReg ret,TCGReg arg);
@@ -187,6 +188,7 @@ static void tcg_out_call(TCGContext *s, const tcg_insn_unit *target,static TCGReg tcg_target_call_oarg_reg (TCGCallReturnKind kind,int slot);static bool tcg_target_const_match (int64_t val,int ct,TCGType type,TCGCond cond,int vece); +static void tcg_out_label_cb (TCGContext *s,TCGLabel *l);#ifndef CONFIG_USER_ONLY #define guest_base ({ qemu_build_not_reached(); (uintptr_t)0; })
@@ -361,6 +363,7 @@ static void tcg_out_label(TCGContext *s, TCGLabel *l)tcg_debug_assert (!l->has_value); l->has_value =1 ; l->u.value_ptr =tcg_splitwx_to_rx (s->code_ptr); +tcg_out_label_cb (s, l); }TCGLabel *gen_new_label (void )
@@ -7047,6 +7050,10 @@ int tcg_gen_code(TCGContext *s, TranslationBlock *tb, uint64_t pc_start)if (!tcg_resolve_relocs (s)) {return -2 ; } + i =tcg_out_tb_end (s); +if (i <0 ) { +return i; + }#ifndef CONFIG_TCG_INTERPRETER /* flush instruction cache */
tcg/tci/tcg-target.c.inc +11 -0
@@ -1301,6 +1301,17 @@ static void tcg_out_tb_start(TCGContext *s) /* nothing to do */ } +static int tcg_out_tb_end(TCGContext *s) +{ + /* nothing to do */ + return 0; +} + +static void tcg_out_label_cb(TCGContext *s, TCGLabel *l) +{ + /* nothing to do */ +} + bool tcg_target_has_memory_bswap(MemOp memop) { return true;
tcg/wasm.c +16 -0
@@ -22,6 +22,12 @@#include "tcg/tcg.h" #include "tcg/tcg-ldst.h" +static void tci_args_l (uint32_t insn,const void *tb_ptr,void **l0) +{ +int diff =sextract32 (insn,12 ,20 ); + *l0 = diff ? (void *)tb_ptr + diff :NULL ; +} +static void tci_args_rl (uint32_t insn,const void *tb_ptr,TCGReg *r0,void **l1) {
@@ -397,6 +403,16 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)tci_args_rrr (insn, &r0, &r1, &r2); regs[r0] =ror32 (regs[r1], regs[r2] &31 );break ; +case INDEX_op_br: +tci_args_l (insn, tb_ptr, &ptr); + tb_ptr = ptr; +continue ; +case INDEX_op_brcond: +tci_args_rl (insn, tb_ptr, &r0, &ptr); +if (regs[r0]) { + tb_ptr = ptr; + } +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target.c.inc +196 -0
243 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 29/35 tcg/wasm: Allow switching coroutine from a helper
In reply to Kohei TokunagaEmscripten's Fiber coroutine implements coroutine switching using Asyncify's stack unwinding and rewinding features [1]. When a coroutine yields (i.e. switches out), Asyncify unwinds the stack, returning control to Emscripten's JS code (Fiber.trampoline()). Then execution resumes in the target coroutine by rewinding the stack. Stack unwinding is implemented by a sequence of immediate function returns, while rewinding re-enters the functions in the call stack, skipping any code between the function's entry point and the original call position [2].
This commit updates the TB's Wasm module to allow helper functions to trigger coroutine switching. Particaully, the TB handles the unwinding and rewinding flows as follows:
- The TB check the Asyncify.state JS object after each helper call. If unwinding is in progress, the TB immediately returns to the caller so that the unwinding can continue.
- Each function call is preceded by a block boundary and an update of the BLOCK_IDX variable. This enables rewinding to skip any code between the function's entry point and the original call position.
Additionally, this commit introduces WasmContext.do_init which is a flag indicating whether the TB should reset the BLOCK_IDX variable to 0 (i.e. start from the beginning). call_wasm_tb is a newly introduced wrapper function for the Wasm module's entrypoint and this sets "do_init = 1" to ensure normal TB execution begins at the first block. During a rewinding, the C code does not set do_init to 1, allowing the TB to preserve the BLOCK_IDX value from the previous unwinding and correctly resume execution from the last unwound block.
[1] https://emscripten.org/docs/api_reference/fiber.h.html
[2] https://kripken.github.io/blog/wasm/2019/07/16/asyncify.html#new-asyncify
--- tcg/wasm.c | 3 ++ tcg/wasm.h | 11 ++++++++ tcg/wasm/tcg-target.c.inc | 58 ++++++++++++++++++++++++++++++++++++++- 3 files changed, 71 insertions(+), 1 deletion(-)
tcg/wasm.c +3 -0
@@ -44,6 +44,9 @@ EM_JS_PRE(void*, instantiate_wasm, (void *wasm_begin, const wasm = HEAP8.subarray(DEC_PTR(wasm_begin),DEC_PTR (wasm_begin) + wasm_size);var helper = {}; + helper.u = () => { + return (Asyncify.state != Asyncify.State.Unwinding) ? 1 : 0; + }; const entsize = TCG_TARGET_REG_BITS / 8;for (var i =0 ; i < import_vec_size / entsize; i++) { const idx = memory_v.getBigInt64(
tcg/wasm.h +11 -0
@@ -30,11 +30,22 @@ struct WasmContext {* Pointer to a stack array. */ uint64_t *stack; + +/* +* Flag indicating whether to initialize the block index(1) or not(0). +*/ +uint32_t do_init; };/* Instantiated Wasm function of a TB */ typedef uintptr_t (*wasm_tb_func )(struct WasmContext *); +static inline uintptr_t call_wasm_tb (wasm_tb_func f,struct WasmContext *ctx) +{ + ctx->do_init =1 ;/* reset the block index (rewinding will skip this) */ +return f (ctx); +} +/* * A TB of the Wasm backend starts from a header which contains pointers for * each data stored in the following region in the TB.
tcg/wasm/tcg-target.c.inc +57 -1
133 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 31/35 tcg/wasm: Enable TLB lookup
In reply to Kohei TokunagaThis commit enables Wasm module's qemu_ld and qemu_st to perform TLB lookups, following the approach used in other backends such as RISC-V. Unlike other backends, the Wasm backend cannot use ldst labels, as jumping to specific code addresses (e.g. raddr) is not possible in Wasm. Instead, each TLB lookup is followed by a if branch: if the lookup succeeds, the memory is accessed directly; otherwise, a fallback helper function is invoked. Support for MO_BSWAP is not yet implemented, so has_memory_bswap is set to false.
--- tcg/wasm/tcg-target.c.inc | 225 +++++++++++++++++++++++++++++++++++++- 1 file changed, 222 insertions(+), 3 deletions(-)
tcg/wasm/tcg-target.c.inc +222 -3
@@ -3,8 +3,12 @@ * Tiny Code Generator for QEMU * * Copyright (c) 2009, 2011 Stefan Weil + * Copyright (c) 2018 SiFive, Inc + * Copyright (c) 2008-2009 Arnaud Patard <[email protected]> + * Copyright (c) 2009 Aurelien Jarno <[email protected]> + * Copyright (c) 2008 Fabrice Bellard * - * Based on tci/tcg-target.c.inc + * Based on tci/tcg-target.c.inc and riscv/tcg-target.c.inc * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal
@@ -154,6 +158,11 @@ static const uint8_t tcg_target_reg_index[TCG_TARGET_NB_REGS] = { /* Local variable pointing to WasmContext */ #define CTX_IDX 0 +/* Temporary local variables */ +#define TMP32_LOCAL_0_IDX 1 +#define TMP64_LOCAL_0_IDX 2 +#define TMP64_LOCAL_1_IDX 3 + /* Function index */ #define CHECK_UNWINDING_IDX 0 /* A function to check the Asyncify status */ #define HELPER_IDX_START 1 /* The first index of helper functions */
@@ -170,6 +179,8 @@ typedef enum { OPC_RETURN = 0x0f, OPC_CALL = 0x10, OPC_LOCAL_GET = 0x20, + OPC_LOCAL_SET = 0x21, + OPC_LOCAL_TEE = 0x22, OPC_GLOBAL_GET = 0x23, OPC_GLOBAL_SET = 0x24,
@@ -1217,11 +1228,156 @@ static void *qemu_ld_helper_ptr(uint32_t oi) } } +#define MIN_TLB_MASK_TABLE_OFS INT_MIN + +static uint8_t prepare_host_addr_wasm(TCGContext *s, uint8_t *hit_var, + TCGReg addr_reg, MemOpIdx oi, + bool is_ld) +{ + MemOp opc = get_memop(oi); + TCGAtomAlign aa; + unsigned a_mask; + unsigned s_bits = opc & MO_SIZE; + unsigned s_mask = (1u << s_bits) - 1; + int mem_index = get_mmuidx(oi); + int fast_ofs = tlb_mask_table_ofs(s, mem_index); + int mask_ofs = fast_ofs + offsetof(CPUTLBDescFast, mask); + int table_ofs = fast_ofs + offsetof(CPUTLBDescFast, table); + int add_off = offsetof(CPUTLBEntry, addend); + tcg_target_long compare_mask; + int offset; + + uint8_t tmp1 = TMP64_LOCAL_0_IDX; + uint8_t tmp2 = TMP64_LOCAL_1_IDX; + + if (!tcg_use_softmmu) { + g_assert_not_reached(); + } + + *hit_var = TMP32_LOCAL_0_IDX; + tcg_wasm_out_op_const(s, OPC_I32_CONST, 0); + tcg_wasm_out_op_idx(s, OPC_LOCAL_SET, *hit_var); + + aa = atom_and_align_for_opc(s, opc, MO_ATOM_IFALIGN, false); + a_mask = (1u << aa.align) - 1; + + /* Get the CPUTLBEntry offset */ + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(addr_reg)); + tcg_wasm_out_op_const(s, OPC_I64_CONST, + TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS); + tcg_wasm_out_op(s, OPC_I64_SHR_U); + + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(TCG_AREG0)); + offset = tcg_wasm_out_norm_ptr(s, mask_ofs); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD, 0, offset); + tcg_wasm_out_op(s, OPC_I64_AND); + + /* Get the pointer to the target CPUTLBEntry */ + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(TCG_AREG0)); + offset = tcg_wasm_out_norm_ptr(s, table_ofs); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD, 0, offset); + tcg_wasm_out_op(s, OPC_I64_ADD); + tcg_wasm_out_op_idx(s, OPC_LOCAL_TEE, tmp1); + + /* Load the tlb copmarator */ + offset = tcg_wasm_out_norm_ptr(s, is_ld ? offsetof(CPUTLBEntry, addr_read) + : offsetof(CPUTLBEntry, addr_write)); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD, 0, offset); + + /* + * For aligned accesses, we check the first byte and include the + * alignment bits within the address. For unaligned access, we + * check that we don't cross pages using the address of the last + * byte of the access. + */ + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(addr_reg)); + if (a_mask < s_mask) { + tcg_wasm_out_op_const(s, OPC_I64_CONST, s_mask - a_mask); + tcg_wasm_out_op(s, OPC_I64_ADD); + } + compare_mask = (uint64_t)TARGET_PAGE_MASK | a_mask; + tcg_wasm_out_op_const(s, OPC_I64_CONST, compare_mask); + tcg_wasm_out_op(s, OPC_I64_AND); + + /* Compare masked address with the TLB entry. */ + tcg_wasm_out_op(s, OPC_I64_EQ); + + tcg_wasm_out_op_block(s, OPC_IF, BLOCK_NORET); + + /* TLB Hit - translate address using addend. */ + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, tmp1); + offset = tcg_wasm_out_norm_ptr(s, add_off); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD, 0, offset); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(addr_reg)); + tcg_wasm_out_op(s, OPC_I64_ADD); + tcg_wasm_out_op_idx(s, OPC_LOCAL_SET, tmp2); + tcg_wasm_out_op_const(s, OPC_I32_CONST, 1); + tcg_wasm_out_op_idx(s, OPC_LOCAL_SET, *hit_var); + + tcg_wasm_out_op(s, OPC_END); + + return tmp2; +} + +static void tcg_wasm_out_qemu_ld_direct( + TCGContext *s, TCGReg r, uint8_t base, MemOp opc) +{ + intptr_t ofs; + switch (opc & (MO_SSIZE)) { + case MO_UB: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD8_U, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(r)); + break; + case MO_SB: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD8_S, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(r)); + break; + case MO_UW: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD16_U, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(r)); + break; + case MO_SW: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD16_S, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(r)); + break; + case MO_UL: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD32_U, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(r)); + break; + case MO_SL: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD32_S, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(r)); + break; + case MO_UQ: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(r)); + break; + default: + g_assert_not_reached(); + } +} + static void tcg_wasm_out_qemu_ld(TCGContext *s, TCGReg data_reg, TCGReg addr_reg, MemOpIdx oi) { intptr_t helper_idx; int64_t func_idx; + MemOp mop = get_memop(oi); + uint8_t base_var, hit_var; helper_idx = (intptr_t)qemu_ld_helper_ptr(oi); func_idx = get_helper_idx(s, helper_idx);
@@ -1230,6 +1386,14 @@ static void tcg_wasm_out_qemu_ld(TCGContext *s, TCGReg data_reg, gen_func_type_qemu_ld(s, oi); } + base_var = prepare_host_addr_wasm(s, &hit_var, addr_reg, oi, true); + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, hit_var); + tcg_wasm_out_op_const(s, OPC_I32_CONST, 1); + tcg_wasm_out_op(s, OPC_I32_EQ); + tcg_wasm_out_op_block(s, OPC_IF, BLOCK_NORET); + tcg_wasm_out_qemu_ld_direct(s, data_reg, base_var, mop); /* fast path */ + tcg_wasm_out_op(s, OPC_END); + /* * update the block index so that the possible rewinding will * skip this block
@@ -1238,6 +1402,10 @@ static void tcg_wasm_out_qemu_ld(TCGContext *s, TCGReg data_reg, tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, BLOCK_IDX); tcg_wasm_out_new_block(s); + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, hit_var); + tcg_wasm_out_op(s, OPC_I32_EQZ); + tcg_wasm_out_op_block(s, OPC_IF, BLOCK_NORET); + /* call the target helper */ tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(TCG_AREG0)); tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(addr_reg));
@@ -1247,6 +1415,8 @@ static void tcg_wasm_out_qemu_ld(TCGContext *s, TCGReg data_reg, tcg_wasm_out_op_idx(s, OPC_CALL, func_idx); tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(data_reg)); tcg_wasm_out_handle_unwinding(s); + + tcg_wasm_out_op(s, OPC_END); } static void *qemu_st_helper_ptr(uint32_t oi)
@@ -1266,12 +1436,47 @@ static void *qemu_st_helper_ptr(uint32_t oi) } } +static void tcg_wasm_out_qemu_st_direct( + TCGContext *s, TCGReg lo, uint8_t base, MemOp opc) +{ + intptr_t ofs; + switch (opc & (MO_SSIZE)) { + case MO_8: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(lo)); + tcg_wasm_out_op_ldst(s, OPC_I64_STORE8, 0, ofs); + break; + case MO_16: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(lo)); + tcg_wasm_out_op_ldst(s, OPC_I64_STORE16, 0, ofs); + break; + case MO_32: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(lo)); + tcg_wasm_out_op_ldst(s, OPC_I64_STORE32, 0, ofs); + break; + case MO_64: + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, base); + ofs = tcg_wasm_out_norm_ptr(s, 0); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(lo)); + tcg_wasm_out_op_ldst(s, OPC_I64_STORE, 0, ofs); + break; + default: + g_assert_not_reached(); + } +} + static void tcg_wasm_out_qemu_st(TCGContext *s, TCGReg data_reg, TCGReg addr_reg, MemOpIdx oi) { intptr_t helper_idx; int64_t func_idx; MemOp mop = get_memop(oi); + uint8_t base_var, hit_var; helper_idx = (intptr_t)qemu_st_helper_ptr(oi); func_idx = get_helper_idx(s, helper_idx);
@@ -1280,6 +1485,14 @@ static void tcg_wasm_out_qemu_st(TCGContext *s, TCGReg data_reg, gen_func_type_qemu_st(s, oi); } + base_var = prepare_host_addr_wasm(s, &hit_var, addr_reg, oi, false); + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, hit_var); + tcg_wasm_out_op_const(s, OPC_I32_CONST, 1); + tcg_wasm_out_op(s, OPC_I32_EQ); + tcg_wasm_out_op_block(s, OPC_IF, BLOCK_NORET); + tcg_wasm_out_qemu_st_direct(s, data_reg, base_var, mop); /* fast path */ + tcg_wasm_out_op(s, OPC_END); + /* * update the block index so that the possible rewinding will * skip this block
@@ -1288,6 +1501,10 @@ static void tcg_wasm_out_qemu_st(TCGContext *s, TCGReg data_reg, tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, BLOCK_IDX); tcg_wasm_out_new_block(s); + tcg_wasm_out_op_idx(s, OPC_LOCAL_GET, hit_var); + tcg_wasm_out_op(s, OPC_I32_EQZ); + tcg_wasm_out_op_block(s, OPC_IF, BLOCK_NORET); + /* call the target helper */ tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(TCG_AREG0)); tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(addr_reg));
@@ -1305,6 +1522,8 @@ static void tcg_wasm_out_qemu_st(TCGContext *s, TCGReg data_reg, tcg_wasm_out_op_idx(s, OPC_CALL, func_idx); tcg_wasm_out_handle_unwinding(s); + + tcg_wasm_out_op(s, OPC_END); } static void tcg_out_op_l(TCGContext *s, TCGOpcode op, TCGLabel *l0)
@@ -2152,7 +2371,7 @@ static const TCGOutOpQemuLdSt outop_qemu_st = { bool tcg_target_has_memory_bswap(MemOp memop) { - return true; + return false; } static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
@@ -2384,7 +2603,7 @@ static const uint8_t mod_3[] = { 0x80, 0x80, 0x80, 0x80, 0x00, /* placeholder for section size*/ 1, /* num of codes */ 0x80, 0x80, 0x80, 0x80, 0x00, /* placeholder for code size */ - 0x0, /* local variables (none) */ + 0x2, 0x1, 0x7f, 0x2, 0x7e, /* local variables (32bit*1, 64bit*2) */ }; #define MOD_3_PH_EXPORT_START_FUNC_IDX 102
Signature · 1 line
2.43.0
PATCH v2 33/35 meson.build: enable to build Wasm backend
In reply to Kohei TokunagaEnable to use tcg/wasm as the TCG backend for the WebAssembly (wasm64) build.
--- include/accel/tcg/getpc.h | 2 +- include/tcg/helper-info.h | 4 ++-- include/tcg/tcg.h | 2 +- meson.build | 6 ++++-- tcg/meson.build | 5 +++++ tcg/region.c | 10 +++++----- tcg/tcg.c | 14 +++++++------- 7 files changed, 25 insertions(+), 18 deletions(-)
include/accel/tcg/getpc.h +1 -1
@@ -9,7 +9,7 @@#define ACCEL_TCG_GETPC_H /* GETPC is the true target of the return instruction that we'll execute. */ -#ifdef CONFIG_TCG_INTERPRETER +#if defined(CONFIG_TCG_INTERPRETER ) || defined(EMSCRIPTEN )extern __threaduintptr_t tci_tb_ptr;# define GETPC () tci_tb_ptr#else
include/tcg/helper-info.h +2 -2
@@ -9,7 +9,7 @@#ifndef TCG_HELPER_INFO_H #define TCG_HELPER_INFO_H -#ifdef CONFIG_TCG_INTERPRETER +#if defined(CONFIG_TCG_INTERPRETER ) || defined(EMSCRIPTEN )#include <ffi.h> #endif #include "tcg-target-reg-bits.h"
@@ -48,7 +48,7 @@ struct TCGHelperInfo {const char *name;/* Used with g_once_init_enter. */ -#ifdef CONFIG_TCG_INTERPRETER +#if defined(CONFIG_TCG_INTERPRETER ) || defined(EMSCRIPTEN )ffi_cif *cif;#else uintptr_t init;
include/tcg/tcg.h +1 -1
@@ -963,7 +963,7 @@ static inline size_t tcg_current_code_size(TCGContext *s)#define TB_EXIT_IDXMAX 1#define TB_EXIT_REQUESTED 3 -#ifdef CONFIG_TCG_INTERPRETER +#if defined(CONFIG_TCG_INTERPRETER ) || defined(EMSCRIPTEN )uintptr_t tcg_qemu_tb_exec (CPUArchState *env,const void *tb_ptr);#else typedef uintptr_t tcg_prologue_fn (CPUArchState *env,const void *tb_ptr);
meson.build +4 -2
@@ -920,9 +920,9 @@ if have_tcg if not get_option('tcg_interpreter') error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu)) endif - elif host_arch == 'wasm32' or host_arch == 'wasm64' + elif host_arch == 'wasm32' if not get_option('tcg_interpreter') - error('WebAssembly host requires --enable-tcg-interpreter') + error('wasm32 host requires --enable-tcg-interpreter') endif elif get_option('tcg_interpreter') warning('Use of the TCG interpreter is not recommended on this host')
@@ -938,6 +938,8 @@ if have_tcg tcg_arch = 'i386' elif host_arch == 'ppc64' tcg_arch = 'ppc' + elif host_arch == 'wasm64' + tcg_arch = 'wasm' endif add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch, language: all_languages)
tcg/meson.build +5 -0
@@ -20,6 +20,11 @@ if get_option('tcg_interpreter') method: 'pkg-config') tcg_ss.add(libffi) tcg_ss.add(files('tci.c')) +elif host_os == 'emscripten' + libffi = dependency('libffi', version: '>=3.0', required: true, + method: 'pkg-config') + specific_ss.add(libffi) + specific_ss.add(files('wasm.c')) endif tcg_ss.add(when: libdw, if_true: files('debuginfo.c'))
tcg/region.c +5 -5
@@ -94,7 +94,7 @@ bool in_code_gen_buffer(const void *p)return (size_t )(p - region.start_aligned) <= region.total_size; } -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN )static int host_prot_read_exec (void ) {#if defined(CONFIG_LINUX ) && defined(HOST_AARCH64 ) && defined(PROT_BTI )
@@ -569,7 +569,7 @@ static int alloc_code_gen_buffer_anon(size_t size, int prot,return prot; } -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN )#ifdef CONFIG_POSIX #include "qemu/memfd.h"
@@ -667,11 +667,11 @@ static int alloc_code_gen_buffer_splitwx_vmremap(size_t size, Error **errp)return PROT_READ |PROT_WRITE ; }#endif /* CONFIG_DARWIN */ -#endif /* CONFIG_TCG_INTERPRETER */ +#endif /* !CONFIG_TCG_INTERPRETER && !EMSCRIPTEN */ static int alloc_code_gen_buffer_splitwx (size_t size,Error **errp) { -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN )# ifdef CONFIG_DARWIN return alloc_code_gen_buffer_splitwx_vmremap (size, errp);# endif
@@ -813,7 +813,7 @@ void tcg_region_init(size_t tb_size, int splitwx, unsigned max_threads)* Work with the page protections set up with the initial mapping. */ need_prot =PROT_READ |PROT_WRITE ; -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN )if (tcg_splitwx_diff ==0 ) { need_prot |=host_prot_read_exec (); }
tcg/tcg.c +7 -7
@@ -256,7 +256,7 @@ TCGv_env tcg_env;const void *tcg_code_gen_epilogue;uintptr_t tcg_splitwx_diff; -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN )tcg_prologue_fn *tcg_qemu_tb_exec;#endif
@@ -1443,7 +1443,7 @@ static TCGHelperInfo info_helper_st128_mmu = { | dh_typemask(ptr, 5) /* uintptr_t ra */ }; -#ifdef CONFIG_TCG_INTERPRETER +#if defined(CONFIG_TCG_INTERPRETER ) || defined(EMSCRIPTEN )static ffi_type *typecode_to_ffi (int argmask) {/*
@@ -1520,7 +1520,7 @@ static ffi_cif *init_ffi_layout(TCGHelperInfo *info)#else #define HELPER_INFO_INIT (I ) (&(I)->init)#define HELPER_INFO_INIT_VAL (I ) 1 -#endif /* CONFIG_TCG_INTERPRETER */ +#endif /* CONFIG_TCG_INTERPRETER || EMSCRIPTEN */ static inline bool arg_slot_reg_p (unsigned arg_slot) {
@@ -1897,7 +1897,7 @@ void tcg_prologue_init(void) s->code_buf = s->code_gen_ptr; s->data_gen_ptr =NULL ; -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN ) tcg_qemu_tb_exec = (tcg_prologue_fn *)tcg_splitwx_to_rx (s->code_ptr);#endif
@@ -1916,7 +1916,7 @@ void tcg_prologue_init(void) prologue_size =tcg_current_code_size (s);perf_report_prologue (s->code_gen_ptr, prologue_size); -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN )flush_idcache_range ((uintptr_t )tcg_splitwx_to_rx (s->code_buf), (uintptr_t )s->code_buf, prologue_size);#endif
@@ -1953,7 +1953,7 @@ void tcg_prologue_init(void) } } -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN )/* * Assert that goto_ptr is implemented completely, setting an epilogue. * For tci, we use NULL as the signal to return from the interpreter,
@@ -7055,7 +7055,7 @@ int tcg_gen_code(TCGContext *s, TranslationBlock *tb, uint64_t pc_start)return i; } -#ifndef CONFIG_TCG_INTERPRETER +#if !defined(CONFIG_TCG_INTERPRETER ) && !defined(EMSCRIPTEN )/* flush instruction cache */ flush_idcache_range((uintptr_t)tcg_splitwx_to_rx(s->code_buf), (uintptr_t)s->code_buf,
Signature · 1 line
2.43.0
PATCH v2 32/35 tcg/wasm: Add tcg_target_init function
In reply to Kohei TokunagaThis commit adds tcg_target_init, aligning it with the Wasm backend's register and stack usage.
--- tcg/wasm/tcg-target.c.inc | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
tcg/wasm/tcg-target.c.inc +29 -0
@@ -2812,3 +2812,32 @@ static int tcg_out_tb_end(TCGContext *s) return 0; } + +static void tcg_target_init(TCGContext *s) +{ + /* The current code uses uint8_t for tcg operations. */ + tcg_debug_assert(tcg_op_defs_max <= UINT8_MAX); + + /* Registers available for 32 bit operations. */ + tcg_target_available_regs[TCG_TYPE_I32] = BIT(TCG_TARGET_NB_REGS) - 1; + /* Registers available for 64 bit operations. */ + tcg_target_available_regs[TCG_TYPE_I64] = BIT(TCG_TARGET_NB_REGS) - 1; + /* + * The TCI "registers" are in the local stack frame and + * cannot be clobbered by the called helper functions. Additionally, Wasm + * modules for a TB and QEMU itself (i.e. helpers) are separated so also + * those variables aren't clobbered by the called helper functions. + * However, the TB assumes a 128-bit return value and assigns to + * the return value registers. + */ + tcg_target_call_clobber_regs = + MAKE_64BIT_MASK(TCG_REG_R0, 128 / TCG_TARGET_REG_BITS); + + s->reserved_regs = 0; + tcg_regset_set_reg(s->reserved_regs, TCG_REG_TMP); + tcg_regset_set_reg(s->reserved_regs, TCG_REG_CALL_STACK); + + /* The call arguments come first, followed by the temp storage. */ + tcg_set_frame(s, TCG_REG_CALL_STACK, TCG_STATIC_CALL_ARGS_SIZE, + TCG_STATIC_FRAME_SIZE); +}
Signature · 1 line
2.43.0
PATCH v2 30/35 tcg/wasm: Enable instantiation of TBs executed many times
In reply to Kohei TokunagaThis commit enables the instantiation and execution of TBs in wasm.c. As in TCI, the tcg_qemu_tb_exec function serves as the entrypoint for the TB execution, handling both instantiation and invocation of the Wasm module. Since browsers cause out of memory error if too many Wasm instances are created, this commit restricts instantiation to TBs that are called many times.
This commit adds a counter (or its array if there are multiple threads) to the TB. Each time a TB is executed on TCI, the counter on TB is incremented. If it reaches to a threshold, that TB is instantiated as Wasm via instantiate_wasm.
The total number of instances are tracked by the instances_global variable and its maximum number is limited by MAX_INSTANCES. When a Wasm module is instantiated, instances_global is incremented and the instance's function pointer is recorded to an array of WasmInstanceInfo.
Each TB refers to the WasmInstanceInfo entry via WasmTBHeader's info_ptr (or its array if there are multiple threads). This allows tcg_qemu_tb_exec to resolve the instance's function pointer from the TB.
When a new instantiation would exceed the limit, the Wasm backend doesn't perform instantiation (i.e. TB continues execution on TCI). Instead, it triggers the removal of older Wasm instances using Emscripten's removeFunction function. Once the removal is completed and detected via FinalizationRegistry API[1], instances_global is decremented, allowing new modules to be instantiated.
--- tcg/wasm.c | 244 +++++++++++++++++++++++++++++++++++++- tcg/wasm.h | 45 +++++++ tcg/wasm/tcg-target.c.inc | 21 ++++ 3 files changed, 307 insertions(+), 3 deletions(-)
V2:
- Added the tcg_target_qemu_prologue stub function.
tcg/wasm.c +241 -3
@@ -24,6 +24,10 @@#include "tcg/helper-info.h" #include <ffi.h> #include <emscripten.h> +#include "wasm.h" + +/* TBs executed more than this value will be compiled to wasm */ +#define INSTANTIATE_NUM 1500 #define EM_JS_PRE(ret, name, args, body...) EM_JS(ret, name, args, body)
@@ -61,6 +65,8 @@ EM_JS_PRE(void*, instantiate_wasm, (void *wasm_begin, "helper" : helper, }); + Module.__wasm_tb.inst_gc_registry.register (inst,"tbinstance" ); +return ENC_PTR (addFunction (inst.exports.start,'ii' )); });
@@ -288,9 +294,53 @@ static void tci_qemu_st(CPUArchState *env, uint64_t taddr, uint64_t val, } } -static uintptr_t tcg_qemu_tb_exec_tci (CPUArchState *env,const void *v_tb_ptr) +static __threadint thread_idx; + +static inline int32_t get_counter_local (void *tb_ptr) +{ +return get_counter (tb_ptr, thread_idx); +} + +static inline void set_counter_local (void *tb_ptr,int v) +{ +set_counter (tb_ptr, thread_idx, v); +} + +static inline struct WasmInstanceInfo *get_info_local (void *tb_ptr) +{ +return get_info (tb_ptr, thread_idx); +} + +static inline void set_info_local (void *tb_ptr,struct WasmInstanceInfo *info) +{ +set_info (tb_ptr, thread_idx, info); +} + +/* +* inc_counter increments the execution counter in the specified TB. +* If the counter reaches the limit, it returns true otherwise returns false. +*/ +static inline bool inc_counter (void *tb_ptr) { -const uint32_t *tb_ptr = v_tb_ptr; +int32_t counter =get_counter_local (tb_ptr); +if ((counter >=0 ) && (counter <INSTANTIATE_NUM )) { +set_counter_local (tb_ptr, counter +1 ); + }else { +return true;/* enter to wasm TB */ + } +return false; +} + +static __threadstruct WasmContext ctx = { + .tb_ptr =0 , + .stack =NULL , + .do_init =1 , + .buf128 =NULL , +}; + +static uintptr_t tcg_qemu_tb_exec_tci (CPUArchState *env) +{ +uint32_t *tb_ptr =get_tci_ptr (ctx.tb_ptr);tcg_target_ulong regs[TCG_TARGET_NB_REGS ];uint64_t stack[(TCG_STATIC_CALL_ARGS_SIZE +TCG_STATIC_FRAME_SIZE ) /sizeof (uint64_t )];
@@ -583,18 +633,32 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)break ;case INDEX_op_exit_tb:tci_args_l (insn, tb_ptr, &ptr); + ctx.tb_ptr =0 ;return (uintptr_t )ptr;case INDEX_op_goto_tb:tci_args_l (insn, tb_ptr, &ptr); - tb_ptr = *(void **)ptr; +if (tb_ptr != *(void **)ptr) { + tb_ptr = *(void **)ptr; + ctx.tb_ptr = tb_ptr; +if (inc_counter (tb_ptr)) { +return 0 ;/* enter to wasm TB */ + } + tb_ptr =get_tci_ptr (tb_ptr); + }break ;case INDEX_op_goto_ptr:tci_args_r (insn, &r0); ptr = (void *)regs[r0];if (!ptr) { + ctx.tb_ptr =0 ;return 0 ; } tb_ptr = ptr; + ctx.tb_ptr = tb_ptr; +if (inc_counter (tb_ptr)) { +return 0 ;/* enter to wasm TB */ + } + tb_ptr =get_tci_ptr (tb_ptr);break ;case INDEX_op_qemu_ld:tci_args_rrm (insn, &r0, &r1, &oi);
@@ -615,3 +679,177 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr) } } } + +/* +* The maximum number of instances that can exist simultaneously +* +* If this limit is reached and a new instance is required, older instances are +* removed to allow creation of new ones without exceeding the browser's limit. +*/ +#define MAX_INSTANCES 15000 + +static int instances_global; + +/* Avoid overwrapping of begin/end pointers */ +#define INSTANCES_BUF_MAX (MAX_INSTANCES + 1) + +static __threadstruct WasmInstanceInfo instances[INSTANCES_BUF_MAX ]; +static __threadint instances_begin; +static __threadint instances_end; + +static void add_instance (wasm_tb_func tb_func,void *tb_ptr) +{ + instances[instances_end].tb_func = tb_func; + instances[instances_end].tb_ptr = tb_ptr; +set_info_local (tb_ptr, &(instances[instances_end])); + instances_end = (instances_end +1 ) %INSTANCES_BUF_MAX ; + +qatomic_inc (&instances_global); +} + +static __threadint instance_pending_gc; +static __threadint instance_done_gc; + +static void remove_old_instances (void ) +{ +int num; +if (instance_pending_gc >0 ) { +return ; + } +if (instances_begin <= instances_end) { + num = instances_end - instances_begin; + }else { + num = instances_end + (INSTANCES_BUF_MAX - instances_begin); + } +/* removes the half of the oldest instances in the buffer */ + num /=2 ; +for (int i =0 ; i < num; i++) { +EM_ASM ({removeFunction ($0); }, instances[instances_begin].tb_func); + instances[instances_begin].tb_ptr =NULL ; + instances_begin = (instances_begin +1 ) %INSTANCES_BUF_MAX ; + } + instance_pending_gc += num; +} + +static bool can_add_instance (void ) +{ +return qatomic_read (&instances_global) <MAX_INSTANCES ; +} + +static wasm_tb_func get_instance_from_tb (void *tb_ptr) +{ +struct WasmInstanceInfo *elm =get_info_local (tb_ptr); +if (elm ==NULL ) { +return NULL ; + } +if (elm->tb_ptr != tb_ptr) { +/* +* This TB was instantiated before, but has been removed. Set counter to +* the max value so that this will be instantiated. +*/ +set_counter_local (tb_ptr,INSTANTIATE_NUM ); +set_info_local (tb_ptr,NULL ); +return NULL ; + } +return elm->tb_func; +} + +static void check_gc_completion (void ) +{ +if (instance_done_gc >0 ) { +qatomic_sub (&instances_global, instance_done_gc); + instance_pending_gc -= instance_done_gc; + instance_done_gc =0 ; + } +} + +EM_JS_PRE(void, init_wasm_js, (void *instance_done_gc), +{ + Module.__wasm_tb = { + inst_gc_registry: new FinalizationRegistry((i) => { + if (i == "tbinstance") { + const memory_v = new DataView(HEAP8.buffer); + let v = memory_v.getInt32(instance_done_gc, true); + memory_v.setInt32(instance_done_gc, v + 1, true); + } + }) + }; +}); + +#define MAX_EXEC_NUM 50000 +static __thread int exec_cnt = MAX_EXEC_NUM; +static inline void trysleep(void) +{ + /* + * Even during running TBs continuously, try to return the control + * to the browser periodically and allow browsers doing tasks. + */ + if (--exec_cnt == 0) { + if (!can_add_instance()) { + emscripten_sleep(0); + check_gc_completion(); + } + exec_cnt = MAX_EXEC_NUM; + } +} + +static int thread_idx_max; + +static void init_wasm(void) +{ + thread_idx = qatomic_fetch_inc(&thread_idx_max); + ctx.stack = g_malloc(TCG_STATIC_CALL_ARGS_SIZE + TCG_STATIC_FRAME_SIZE); + ctx.buf128 = g_malloc(16); + ctx.tci_tb_ptr = (uint32_t *)&tci_tb_ptr; + init_wasm_js(&instance_done_gc); +} + +static __thread bool initdone; + +uintptr_t tcg_qemu_tb_exec(CPUArchState *env, const void *v_tb_ptr) +{ + if (!initdone) { + init_wasm(); + initdone = true; + } + ctx.env = env; + ctx.tb_ptr = (void *)v_tb_ptr; + while (true) { + trysleep(); + uintptr_t res; + wasm_tb_func tb_func = get_instance_from_tb(ctx.tb_ptr); + if (tb_func) { + /* + * Call the Wasm instance + */ + res = call_wasm_tb(tb_func, &ctx); + } else if (!inc_counter(ctx.tb_ptr)) { + /* + * Run it on TCI because the counter value is small + */ + res = tcg_qemu_tb_exec_tci(env); + } else if (!can_add_instance()) { + /* + * Too many instances has been created, try removing older + * instances and keep running this TB on TCI + */ + remove_old_instances(); + check_gc_completion(); + res = tcg_qemu_tb_exec_tci(env); + } else { + /* + * Instantiate and run the Wasm module + */ + struct WasmTBHeader *header = (struct WasmTBHeader *)ctx.tb_ptr; + tb_func = (wasm_tb_func)instantiate_wasm(header->wasm_ptr, + header->wasm_size, + header->import_ptr, + header->import_size); + add_instance(tb_func, ctx.tb_ptr); + res = call_wasm_tb(tb_func, &ctx); + } + if (!ctx.tb_ptr) { + return res; + } + } +}
tcg/wasm.h +45 -0
57 lines not on this page · raw message
tcg/wasm/tcg-target.c.inc +21 -0
@@ -28,6 +28,9 @@ #include "qemu/queue.h" #include "../wasm.h" +/* This is included to get the number of threads via tcg_max_ctxs. */ +#include "../tcg-internal.h" + /* Used for function call generation. */ #define TCG_TARGET_CALL_STACK_OFFSET 0 #define TCG_TARGET_STACK_ALIGN 8
@@ -2295,6 +2298,11 @@ static void tcg_out_set_carry(TCGContext *s) g_assert_not_reached(); } +/* Generate global QEMU prologue and epilogue code. */ +static inline void tcg_target_qemu_prologue(TCGContext *s) +{ +} + static const uint8_t mod_1[] = { 0x0, 0x61, 0x73, 0x6d, /* magic */ 0x01, 0x0, 0x0, 0x0, /* version */
@@ -2443,6 +2451,7 @@ static int write_mod_code(TCGContext *s) static void tcg_out_tb_start(TCGContext *s) { + int size; intptr_t ofs; struct WasmTBHeader *h;
@@ -2457,6 +2466,18 @@ static void tcg_out_tb_start(TCGContext *s) h = (struct WasmTBHeader *)(s->code_ptr); s->code_ptr += sizeof(struct WasmTBHeader); + /* locate counters */ + h->counter_ptr = (int32_t *)s->code_ptr; + size = tcg_max_ctxs * sizeof(int32_t); + memset(s->code_ptr, 0, size); + s->code_ptr += size; + + /* locate the instance information */ + h->info_ptr = (struct WasmInstanceInfo **)s->code_ptr; + size = tcg_max_ctxs * sizeof(void *); + memset(s->code_ptr, 0, size); + s->code_ptr += size; + /* Followed by TCI code */ h->tci_ptr = s->code_ptr;
Signature · 1 line
2.43.0
PATCH v2 34/35 meson.build: Propagate optimization flag for linking on Emscripten
In reply to Kohei TokunagaEmscripten uses the optimization flag at the link time to enable optimizations via Binaryen [1]. While meson.build currently recognizes the -Doptimization option, it does not propagate it to the linking. This commit updates meson.build to propagate the optimization flag to the linking when targeting WebAssembly.
[1] https://emscripten.org/docs/optimizing/Optimizing-Code.html#how-emscripten-optimizes
--- meson.build | 6 ++++++ 1 file changed, 6 insertions(+)
meson.build +6 -0
@@ -878,6 +878,12 @@ elif host_os == 'openbsd' # Disable OpenBSD W^X if available emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded') endif +elif host_os == 'emscripten' + # Emscripten uses the optimization flag also during the link time. + # https://emscripten.org/docs/optimizing/Optimizing-Code.html#how-emscripten-optimizes + if get_option('optimization') != 'plain' + emulator_link_args += ['-O' + get_option('optimization')] + endif endif ###############################################
Signature · 1 line
2.43.0
PATCH v2 35/35 .gitlab-ci.d: build wasm backend in CI
In reply to Kohei TokunagaThis commit adds the build tests for the wasm backend.
--- .gitlab-ci.d/buildtest.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
.gitlab-ci.d/buildtest.yml +2 -2
@@ -803,7 +803,7 @@ build-wasm64-64bit: job: wasm64-64bit-emsdk-cross-container variables: IMAGE: emsdk-wasm64-64bit-cross - CONFIGURE_ARGS: --static --cpu=wasm64 --disable-tools --enable-debug --enable-tcg-interpreter + CONFIGURE_ARGS: --static --cpu=wasm64 --disable-tools --enable-debug build-wasm64-32bit: extends: .wasm_build_job_template
@@ -812,4 +812,4 @@ build-wasm64-32bit: job: wasm64-32bit-emsdk-cross-container variables: IMAGE: emsdk-wasm64-32bit-cross - CONFIGURE_ARGS: --static --cpu=wasm64 --enable-wasm64-32bit-address-limit --disable-tools --enable-debug --enable-tcg-interpreter + CONFIGURE_ARGS: --static --cpu=wasm64 --enable-wasm64-32bit-address-limit --disable-tools --enable-debug
Signature · 1 line
2.43.0
PATCH v2 26/35 tcg/wasm: Add initialization of fundamental registers
In reply to Kohei TokunagaThis commit adds initialization of TCG_AREG0 and TCG_REG_CALL_STACK at the beginning of each TB. The CPUArchState struct and the stack array are passed from the caller via the WasmContext structure. The BLOCK_IDX variable is initialized to 0 as TB execution begins at the first block.
--- tcg/wasm.h | 10 ++++++++++ tcg/wasm/tcg-target.c.inc | 19 +++++++++++++++++++ 2 files changed, 29 insertions(+)
tcg/wasm.h +10 -0
@@ -20,6 +20,16 @@ struct WasmContext {* Buffer to store 128bit return value on call. */ void *buf128; + +/* +* Pointer to the CPUArchState struct. +*/ +CPUArchState *env; + +/* +* Pointer to a stack array. +*/ + uint64_t *stack; };#endif
tcg/wasm/tcg-target.c.inc +19 -0
@@ -2071,11 +2071,30 @@ static void tcg_out_set_carry(TCGContext *s) static void tcg_out_tb_start(TCGContext *s) { + intptr_t ofs; + init_sub_buf(); init_blocks(); init_label_info(); init_helpers(); + /* Initialize fundamental registers */ + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(TCG_AREG0)); + tcg_wasm_out_op(s, OPC_I64_EQZ); + tcg_wasm_out_op_block(s, OPC_IF, BLOCK_NORET); + + ofs = tcg_wasm_out_get_ctx(s, CTX_OFFSET(env)); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(TCG_AREG0)); + + ofs = tcg_wasm_out_get_ctx(s, CTX_OFFSET(stack)); + tcg_wasm_out_op_ldst(s, OPC_I64_LOAD, 0, ofs); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(TCG_REG_CALL_STACK)); + tcg_wasm_out_op(s, OPC_END); + + tcg_wasm_out_op_const(s, OPC_I64_CONST, 0); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, BLOCK_IDX); + tcg_wasm_out_op_block(s, OPC_LOOP, BLOCK_NORET); tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, BLOCK_IDX); tcg_wasm_out_op(s, OPC_I64_EQZ);
Signature · 1 line
2.43.0
PATCH v2 28/35 tcg/wasm: Implement instantiation of Wasm binary
In reply to Kohei Tokunagainstantiate_wasm is a function that instantiates a TB's Wasm binary, importing the functions as specified by its arguments. Following the header definition in wasm/tcg-target.c.inc, QEMU's memory is imported into the module as "env.memory", and helper functions are imported as "helper.<idx>".
The instantiated Wasm module is imported to QEMU using Emscripten's "addFunction" feature[1] which returns a function pointer. This allows QEMU to call this module directly from C code via that pointer.
Since the subarray() method doesn't accept a BigInt value which is used for the 64bit pointer value, it is converted to a Number (i53) using bigintToI53Checked method of Emscripten. Although this conversion (64bit to 53bit) drops higher bits, the maximum memory size of the engine implementations is currently limited to 16GiB[2] so we can assume that the pointers are within the Number's range.
Note that since FireFox 138, WebAssembly.Module no longer accepts a SharedArrayBuffer as input [3] as reported by Nicolas Vandeginste in my fork[4]. This commit ensures that WebAssembly.Module() is passed a Uint8Array created from the binary data on a SharedArrayBuffer.
[1] https://emscripten.org/docs/porting/connecting_cpp_and_javascript/Interacting-with-code.html#calling-javascript-functions-as-function-pointers-from-c
[2] https://webassembly.github.io/memory64/js-api/#limits
[3] https://bugzilla.mozilla.org/show_bug.cgi?id=1965217
[4] https://github.com/ktock/qemu-wasm/pull/25
--- tcg/wasm.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)
tcg/wasm.c +37 -0
@@ -23,6 +23,43 @@#include "tcg/tcg-ldst.h" #include "tcg/helper-info.h" #include <ffi.h> +#include <emscripten.h> + +#define EM_JS_PRE(ret, name, args, body...) EM_JS(ret, name, args, body) + +#define DEC_PTR (p) bigintToI53Checked(p) +#define ENC_PTR (p) BigInt(p) +#if defined(WASM64_MEMORY64_2 ) +#define ENC_WASM_TABLE_IDX (i) Number(i) +#else +#define ENC_WASM_TABLE_IDX (i) i +#endif + +EM_JS_PRE(void*, instantiate_wasm, (void *wasm_begin, + int wasm_size, + void *import_vec_begin, + int import_vec_size), +{ + const memory_v = new DataView(HEAP8.buffer); + const wasm = HEAP8.subarray(DEC_PTR(wasm_begin), +DEC_PTR (wasm_begin) + wasm_size); +var helper = {}; + const entsize = TCG_TARGET_REG_BITS / 8; +for (var i =0 ; i < import_vec_size / entsize; i++) { + const idx = memory_v.getBigInt64( +DEC_PTR (import_vec_begin) + i * entsize, true); + helper[i] = wasmTable.get (ENC_WASM_TABLE_IDX (idx)); + } + const mod = new WebAssembly.Module(new Uint8Array(wasm)); + const inst = new WebAssembly.Instance(mod, { + "env" : { + "memory" : wasmMemory, + }, + "helper" : helper, + }); + +return ENC_PTR (addFunction (inst.exports.start,'ii' )); +}); __threaduintptr_t tci_tb_ptr;
Signature · 1 line
2.43.0
PATCH v2 25/35 tcg/wasm: Mark unimplemented instructions
In reply to Kohei TokunagaThis commit adds the C_NotImplemented constraint and provides stubs for the functions that aren't implemented in the Wasm backend.
--- tcg/wasm/tcg-target.c.inc | 119 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+)
V2:
- Added C_NotImplemented constraints and stubs of removed instructions.
tcg/wasm/tcg-target.c.inc +119 -0
@@ -1950,6 +1950,125 @@ static void tcg_out_mb(TCGContext *s, unsigned a0) tcg_wasm_out8(s, 0x00); } +static const TCGOutOpDeposit outop_deposit = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpExtract outop_extract = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpExtract2 outop_extract2 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_addco = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpAddSubCarry outop_addci = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_addcio = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpAddSubCarry outop_subbo = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpAddSubCarry outop_subbi = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpAddSubCarry outop_subbio = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpUnary outop_not = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_andc = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_eqv = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_nand = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_nor = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_orc = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpDivRem outop_divs2 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpDivRem outop_divu2 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpMul2 outop_muls2 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_mulsh = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpMul2 outop_mulu2 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBinary outop_muluh = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBswap outop_bswap16 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpBswap outop_bswap32 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpUnary outop_bswap64 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpQemuLdSt2 outop_qemu_ld2 = { + .base.static_constraint = C_NotImplemented, +}; + +static const TCGOutOpQemuLdSt2 outop_qemu_st2 = { + .base.static_constraint = C_NotImplemented, +}; + +static bool tcg_out_xchg(TCGContext *s, TCGType type, TCGReg r1, TCGReg r2) +{ + return false; +} + +static void tcg_out_set_borrow(TCGContext *s) +{ + g_assert_not_reached(); +} + +static void tcg_out_set_carry(TCGContext *s) +{ + g_assert_not_reached(); +} + static void tcg_out_tb_start(TCGContext *s) { init_sub_buf();
Signature · 1 line
2.43.0
PATCH v2 10/35 tcg/wasm: Add add/sub/mul instructions
In reply to Kohei TokunagaThe add, sub and mul operations are implemented using the corresponding instructions in Wasm. TCI instructions are also generated in the same way as the original TCI backend.
--- tcg/wasm.c | 12 ++++++++++++ tcg/wasm/tcg-target.c.inc | 39 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
tcg/wasm.c +12 -0
@@ -59,6 +59,18 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)tci_args_rrr (insn, &r0, &r1, &r2); regs[r0] = regs[r1] ^ regs[r2];break ; +case INDEX_op_add: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = regs[r1] + regs[r2]; +break ; +case INDEX_op_sub: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = regs[r1] - regs[r2]; +break ; +case INDEX_op_mul: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = regs[r1] * regs[r2]; +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target.c.inc +39 -0
@@ -140,6 +140,9 @@ typedef enum { OPC_GLOBAL_GET = 0x23, OPC_GLOBAL_SET = 0x24, + OPC_I64_ADD = 0x7c, + OPC_I64_SUB = 0x7d, + OPC_I64_MUL = 0x7e, OPC_I64_AND = 0x83, OPC_I64_OR = 0x84, OPC_I64_XOR = 0x85,
@@ -265,6 +268,42 @@ static const TCGOutOpBinary outop_xor = { .out_rrr = tgen_xor, }; +static void tgen_add(TCGContext *s, TCGType type, + TCGReg a0, TCGReg a1, TCGReg a2) +{ + tcg_out_op_rrr(s, INDEX_op_add, a0, a1, a2); + tcg_wasm_out_o1_i2(s, OPC_I64_ADD, a0, a1, a2); +} + +static const TCGOutOpBinary outop_add = { + .base.static_constraint = C_O1_I2(r, r, r), + .out_rrr = tgen_add, +}; + +static void tgen_sub(TCGContext *s, TCGType type, + TCGReg a0, TCGReg a1, TCGReg a2) +{ + tcg_out_op_rrr(s, INDEX_op_sub, a0, a1, a2); + tcg_wasm_out_o1_i2(s, OPC_I64_SUB, a0, a1, a2); +} + +static const TCGOutOpSubtract outop_sub = { + .base.static_constraint = C_O1_I2(r, r, r), + .out_rrr = tgen_sub, +}; + +static void tgen_mul(TCGContext *s, TCGType type, + TCGReg a0, TCGReg a1, TCGReg a2) +{ + tcg_out_op_rrr(s, INDEX_op_mul, a0, a1, a2); + tcg_wasm_out_o1_i2(s, OPC_I64_MUL, a0, a1, a2); +} + +static const TCGOutOpBinary outop_mul = { + .base.static_constraint = C_O1_I2(r, r, r), + .out_rrr = tgen_mul, +}; + static void tcg_out_tb_start(TCGContext *s) { init_sub_buf();
Signature · 1 line
2.43.0
PATCH v2 27/35 tcg/wasm: Write wasm binary to TB
In reply to Kohei TokunagaThis commit updates tcg_out_tb_start and tcg_out_tb_end to emit Wasm binaries into the TB code buffer. The generated Wasm binary defines a function of type wasm_tb_func which takes a WasmContext, executes the TB, and returns a result. In the Wasm backend, each TB starts with a WasmTBHeader which contains pointers to the following data:
- TCI code
- Wasm code
- Array of helper function pointers imported into the Wasm instance
tcg_out_tb_start writes the WasmTBHeader to the code buffer. tcg_out_tb_end generates the full Wasm executable binary by creating the Wasm module header following the spec[1][2][3] and copying the Wasm code body from sub_buf to the TB. This Wasm binary is placed after the TCI code which was emitted earlier.
Additionally, an array of imported function pointers is appended to the TB. They are used during Wasm module instantiation. Function are imported to Wasm with names like "helper.0", "helper.1", etc., where the number corresponds to the array index.
Each function's type signature must also be encoded in the Wasm module header. To support this, every emission of "call", "qemu_ld" and "qemu_st" operations also records the target function's type information in a buffer which will be copied to the code buffer during tcg_out_tb_end.
Memory is shared between QEMU and the TBs and is imported to the Wasm module with the name "env.memory".
[1] https://webassembly.github.io/spec/core/binary/modules.html
[2] https://github.com/WebAssembly/threads/blob/b2567bff61ee6fbe731934f0ed17a5d48dc9ab01/proposals/threads/Overview.md
[3] https://github.com/WebAssembly/memory64/blob/9003cd5e24e53b84cd9027ea3dd7ae57159a6db1/proposals/memory64/Overview.md
--- tcg/wasm.h | 26 +++ tcg/wasm/tcg-target.c.inc | 406 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 432 insertions(+)
tcg/wasm.h +26 -0
@@ -32,4 +32,30 @@ struct WasmContext { uint64_t *stack; }; +/* Instantiated Wasm function of a TB */ +typedef uintptr_t (*wasm_tb_func )(struct WasmContext *); + +/* +* A TB of the Wasm backend starts from a header which contains pointers for +* each data stored in the following region in the TB. +*/ +struct WasmTBHeader { +/* +* Pointer to the region containing TCI instructions. +*/ +void *tci_ptr; + +/* +* Pointer to the region containing Wasm instructions. +*/ +void *wasm_ptr; +int wasm_size; + +/* +* Pointer to the array containing imported function pointers. +*/ +void *import_ptr; +int import_size; +}; +#endif
tcg/wasm/tcg-target.c.inc +406 -0
487 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 15/35 tcg/wasm: Add mov/movi instructions
In reply to Kohei TokunagaTheese operations are implemented using the corresponding instructions in Wasm. TCI instructions are also generated in the same way as the original TCI backend.
--- tcg/wasm.c | 4 ++++ tcg/wasm/tcg-target.c.inc | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
tcg/wasm.c +4 -0
@@ -260,6 +260,10 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr) tmp32 =tci_compare32 (regs[r1], regs[r2], condition); regs[r0] = regs[tmp32 ? r3 : r4];break ; +case INDEX_op_mov: +tci_args_rr (insn, &r0, &r1); + regs[r0] = regs[r1]; +break ;case INDEX_op_tci_movi:tci_args_ri (insn, &r0, &t1); regs[r0] = t1;
tcg/wasm/tcg-target.c.inc +36 -0
@@ -501,6 +501,28 @@ static void tcg_wasm_out_st( tcg_wasm_out_op_ldst(s, opc, 0, offset); } +static void tcg_wasm_out_mov(TCGContext *s, TCGReg ret, TCGReg arg) +{ + tcg_wasm_out_op_idx(s, OPC_GLOBAL_GET, REG_IDX(arg)); + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(ret)); +} + +static void tcg_wasm_out_movi(TCGContext *s, TCGType type, + TCGReg ret, tcg_target_long arg) +{ + switch (type) { + case TCG_TYPE_I32: + tcg_wasm_out_op_const(s, OPC_I64_CONST, (int32_t)arg); + break; + case TCG_TYPE_I64: + tcg_wasm_out_op_const(s, OPC_I64_CONST, arg); + break; + default: + g_assert_not_reached(); + } + tcg_wasm_out_op_idx(s, OPC_GLOBAL_SET, REG_IDX(ret)); +} + static void tcg_out_op_ri(TCGContext *s, TCGOpcode op, TCGReg r0, int32_t i1) { tcg_insn_unit_tci insn = 0;
@@ -798,6 +820,20 @@ static void tcg_tci_out_movi(TCGContext *s, TCGType type, } } +static bool tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg) +{ + tcg_out_op_rr(s, INDEX_op_mov, ret, arg); + tcg_wasm_out_mov(s, ret, arg); + return true; +} + +static void tcg_out_movi(TCGContext *s, TCGType type, + TCGReg ret, tcg_target_long arg) +{ + tcg_tci_out_movi(s, type, ret, arg); + tcg_wasm_out_movi(s, type, ret, arg); +} + static void stack_bounds_check(TCGReg base, intptr_t offset) { if (base == TCG_REG_CALL_STACK) {
Signature · 1 line
2.43.0
PATCH v2 23/35 tcg/wasm: Add qemu_ld/qemu_st instructions
In reply to Kohei TokunagaThis commit adds qemu_ld and qemu_st by calling the helper functions corresponding to MemOp.
--- tcg/wasm.c | 70 ++++++++++++++++++ tcg/wasm/tcg-target-has.h | 1 + tcg/wasm/tcg-target.c.inc | 145 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 216 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
tcg/wasm.c +70 -0
@@ -63,6 +63,14 @@ static void tci_args_ri(uint32_t insn, TCGReg *r0, tcg_target_ulong *i1) *i1 =sextract32 (insn,12 ,20 ); } +static void tci_args_rrm (uint32_t insn,TCGReg *r0, +TCGReg *r1,MemOpIdx *m2) +{ + *r0 =extract32 (insn,8 ,4 ); + *r1 =extract32 (insn,12 ,4 ); + *m2 =extract32 (insn,16 ,16 ); +} +static void tci_args_rrr (uint32_t insn,TCGReg *r0,TCGReg *r1,TCGReg *r2) { *r0 =extract32 (insn,8 ,4 );
@@ -190,6 +198,56 @@ static bool tci_compare64(uint64_t u0, uint64_t u1, TCGCond condition)return result; } +static uint64_t tci_qemu_ld (CPUArchState *env,uint64_t taddr, +MemOpIdx oi,const void *tb_ptr) +{ +MemOp mop =get_memop (oi); +uintptr_t ra = (uintptr_t )tb_ptr; + +switch (mop &MO_SSIZE ) { +case MO_UB : +return helper_ldub_mmu (env, taddr, oi, ra); +case MO_SB : +return helper_ldsb_mmu (env, taddr, oi, ra); +case MO_UW : +return helper_lduw_mmu (env, taddr, oi, ra); +case MO_SW : +return helper_ldsw_mmu (env, taddr, oi, ra); +case MO_UL : +return helper_ldul_mmu (env, taddr, oi, ra); +case MO_SL : +return helper_ldsl_mmu (env, taddr, oi, ra); +case MO_UQ : +return helper_ldq_mmu (env, taddr, oi, ra); +default : +g_assert_not_reached (); + } +} + +static void tci_qemu_st (CPUArchState *env,uint64_t taddr,uint64_t val, +MemOpIdx oi,const void *tb_ptr) +{ +MemOp mop =get_memop (oi); +uintptr_t ra = (uintptr_t )tb_ptr; + +switch (mop &MO_SIZE ) { +case MO_UB : +helper_stb_mmu (env, taddr, val, oi, ra); +break ; +case MO_UW : +helper_stw_mmu (env, taddr, val, oi, ra); +break ; +case MO_UL : +helper_stl_mmu (env, taddr, val, oi, ra); +break ; +case MO_UQ : +helper_stq_mmu (env, taddr, val, oi, ra); +break ; +default : +g_assert_not_reached (); + } +} +static uintptr_t tcg_qemu_tb_exec_tci (CPUArchState *env,const void *v_tb_ptr) {const uint32_t *tb_ptr = v_tb_ptr;
@@ -208,6 +266,8 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)uint8_t pos, len;TCGCond condition;uint32_t tmp32; +uint64_t taddr; +MemOpIdx oi;int32_t ofs;void *ptr;
@@ -496,6 +556,16 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr) } tb_ptr = ptr;break ; +case INDEX_op_qemu_ld: +tci_args_rrm (insn, &r0, &r1, &oi); + taddr = regs[r1]; + regs[r0] =tci_qemu_ld (env, taddr, oi, tb_ptr); +break ; +case INDEX_op_qemu_st: +tci_args_rrm (insn, &r0, &r1, &oi); + taddr = regs[r1]; +tci_qemu_st (env, taddr, regs[r0], oi, tb_ptr); +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target-has.h +1 -0
@@ -4,6 +4,7 @@#define TCG_TARGET_HAS_tst 0#define TCG_TARGET_HAS_extr_i64_i32 0 +#define TCG_TARGET_HAS_qemu_ldst_i128 0#define TCG_TARGET_extract_valid (type, ofs, len) 0#define TCG_TARGET_sextract_valid (type, ofs, len) \
tcg/wasm/tcg-target.c.inc +145 -0
163 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 19/35 tcg/wasm: Add rot/clz/ctz instructions
In reply to Kohei TokunagaThe rot/clz/ctz operations are implemented using the corresponding instructions in Wasm. TCI instructions are also generated in the same way as the original TCI backend.
--- tcg/wasm.c | 34 +++++++++++ tcg/wasm/tcg-target-opc.h.inc | 4 ++ tcg/wasm/tcg-target.c.inc | 107 ++++++++++++++++++++++++++++++++++ 3 files changed, 145 insertions(+)
V2:
- This commit generates both Wasm and TCI instrucitons.
tcg/wasm.c +34 -0
@@ -363,6 +363,40 @@ static uintptr_t tcg_qemu_tb_exec_tci(CPUArchState *env, const void *v_tb_ptr)tci_args_rr (insn, &r0, &r1); regs[r0] =ctpop64 (regs[r1]);break ; +case INDEX_op_clz: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = regs[r1] ?clz64 (regs[r1]) : regs[r2]; +break ; +case INDEX_op_ctz: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] = regs[r1] ?ctz64 (regs[r1]) : regs[r2]; +break ; +case INDEX_op_tci_clz32: +tci_args_rrr (insn, &r0, &r1, &r2); + tmp32 = regs[r1]; + regs[r0] = tmp32 ?clz32 (tmp32) : regs[r2]; +break ; +case INDEX_op_tci_ctz32: +tci_args_rrr (insn, &r0, &r1, &r2); + tmp32 = regs[r1]; + regs[r0] = tmp32 ?ctz32 (tmp32) : regs[r2]; +break ; +case INDEX_op_rotl: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] =rol64 (regs[r1], regs[r2] &63 ); +break ; +case INDEX_op_rotr: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] =ror64 (regs[r1], regs[r2] &63 ); +break ; +case INDEX_op_tci_rotl32: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] =rol32 (regs[r1], regs[r2] &31 ); +break ; +case INDEX_op_tci_rotr32: +tci_args_rrr (insn, &r0, &r1, &r2); + regs[r0] =ror32 (regs[r1], regs[r2] &31 ); +break ;default :g_assert_not_reached (); }
tcg/wasm/tcg-target-opc.h.inc +4 -0
@@ -12,3 +12,7 @@ DEF(tci_divs32, 1, 2, 0, TCG_OPF_NOT_PRESENT) DEF(tci_divu32, 1, 2, 0, TCG_OPF_NOT_PRESENT) DEF(tci_rems32, 1, 2, 0, TCG_OPF_NOT_PRESENT) DEF(tci_remu32, 1, 2, 0, TCG_OPF_NOT_PRESENT) +DEF(tci_clz32, 1, 2, 0, TCG_OPF_NOT_PRESENT) +DEF(tci_ctz32, 1, 2, 0, TCG_OPF_NOT_PRESENT) +DEF(tci_rotl32, 1, 2, 0, TCG_OPF_NOT_PRESENT) +DEF(tci_rotr32, 1, 2, 0, TCG_OPF_NOT_PRESENT)
tcg/wasm/tcg-target.c.inc +107 -0
156 lines not on this page · raw message
Signature · 1 line
2.43.0