From f729da7656910faaef00ba897a01595a5c44a94d Mon Sep 17 00:00:00 2001 From: "Zhang, Yi" Date: Thu, 9 May 2024 16:15:44 +0800 Subject: [PATCH] Add test cases for the requirements of "gc-aot" feature (#3399) --- tests/requirement-engineering/README.md | 74 + tests/requirement-engineering/gc-aot/build.py | 74 + .../gc-aot/build_spec_interpreter.sh | 23 + tests/requirement-engineering/gc-aot/run.py | 103 + .../requirement-engineering/gc-aot/runtest.py | 1589 ++++++++++++ .../gc-aot/test_cases.json | 115 + .../gc-aot/wasm-apps/array.wast | 308 +++ .../gc-aot/wasm-apps/array_copy.wast | 139 ++ .../gc-aot/wasm-apps/array_fill.wast | 81 + .../gc-aot/wasm-apps/br_on_cast.wast | 267 ++ .../gc-aot/wasm-apps/br_on_cast_fail.wast | 282 +++ .../gc-aot/wasm-apps/call_ref.wast | 208 ++ .../gc-aot/wasm-apps/extern.wast | 54 + .../gc-aot/wasm-apps/i31.wast | 51 + .../gc-aot/wasm-apps/local_set.wast | 362 +++ .../gc-aot/wasm-apps/local_tee.wast | 639 +++++ .../gc-aot/wasm-apps/ref_cast.wast | 186 ++ .../gc-aot/wasm-apps/ref_eq.wast | 168 ++ .../gc-aot/wasm-apps/ref_test.wast | 331 +++ .../gc-aot/wasm-apps/return_call_ref.wast | 376 +++ .../gc-aot/wasm-apps/select.wast | 592 +++++ .../gc-aot/wasm-apps/struct.wast | 229 ++ .../gc-aot/wasm-apps/table_fill.wast | 157 ++ .../gc-aot/wasm-apps/table_get.wast | 88 + .../gc-aot/wasm-apps/table_grow.wast | 176 ++ .../gc-aot/wasm-apps/table_init.wast | 2149 +++++++++++++++++ .../gc-aot/wasm-apps/table_set.wast | 119 + .../gc-aot/wasm-apps/type_subtyping.wast | 804 ++++++ .../run_requirement.py | 215 ++ tests/wamr-test-suites/test_wamr.sh | 40 +- 30 files changed, 9995 insertions(+), 4 deletions(-) create mode 100644 tests/requirement-engineering/README.md create mode 100644 tests/requirement-engineering/gc-aot/build.py create mode 100755 tests/requirement-engineering/gc-aot/build_spec_interpreter.sh create mode 100755 tests/requirement-engineering/gc-aot/run.py create mode 100755 tests/requirement-engineering/gc-aot/runtest.py create mode 100644 tests/requirement-engineering/gc-aot/test_cases.json create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/array.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/array_copy.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/array_fill.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/br_on_cast.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/br_on_cast_fail.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/call_ref.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/extern.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/i31.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/local_set.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/local_tee.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/ref_cast.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/ref_eq.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/ref_test.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/return_call_ref.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/select.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/struct.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/table_fill.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/table_get.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/table_grow.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/table_init.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/table_set.wast create mode 100644 tests/requirement-engineering/gc-aot/wasm-apps/type_subtyping.wast create mode 100755 tests/wamr-test-suites/requirement-engineering-test-script/run_requirement.py diff --git a/tests/requirement-engineering/README.md b/tests/requirement-engineering/README.md new file mode 100644 index 00000000..e8c87dc9 --- /dev/null +++ b/tests/requirement-engineering/README.md @@ -0,0 +1,74 @@ +# Requirement Engineering Tests + +This directory contains requirement engineering test cases. Each directory corresponds to a test case suite for a requirement, comprised of test cases for sub-requirements. + +## How to Run a Requirement Test + +You can use the [all-in-one script](../wamr-test-suites/test_wamr.sh). Here are examples of its usage for testing the "gc-aot" requirement: + +```shell +cd ../wamr-test-suites +# Run "gc-aot" requirement test on cases corresponding to sub-requirement ids 1, 2, 3 +./test_wamr.sh -r "gc-aot" 1 2 3 +# If no sub-requirement id is specified, it will test all cases for this requirement +./test_wamr.sh -r "gc-aot" +``` + +Or, use the helper scripts under a specific requirement directory. Refer to the help information of that helper script: + +```shell +cd gc-aot +# Build first +./build.py + +# Print help info +./run.py -h +# Test sub-requirement 1, and output to file output.csv +./run.py -o output 1 +# Test all sub-requirements, and output to file output.csv +./run.py -o output +``` + +## How to Add a New Requirement Test + +1. First, create a subdirectory, e.g., `new-requirement`, in this directory. Its name should reflect the requirement, like "gc-aot", and it should contain two helper scripts (`build.py` and `run.py`) to build and run tests under the `new-requirement` sub-directory. + + > If you need to use relative paths in your script, it's fine. The caller Python script [../wamr-test-suites/requirement-engineering-test-script/run_requirement.py](../wamr-test-suites/requirement-engineering-test-script/run_requirement.py) will use `os.chdir()` to change to that sub-directory. + + Start by writing and testing the helper script in that sub-directory, and add anything helpful (for instance, a main function and CLI argument parser). + +2. After finishing the helper script, to let [the all-in-one script `test_wamr.sh`](../wamr-test-suites/test_wamr.sh) -> [../wamr-test-suites/requirement-engineering-test-script/run_requirement.py](../wamr-test-suites/requirement-engineering-test-script/run_requirement.py) invoke the new requirement test, you don't have to modify this script. Just ensure your helper script follows these guidelines: + + - The `build.py` should have a **build** function to build everything necessary for running the requirement tests. The signature should be: + + ```Python + def build(verbose: bool) -> None: + # your implementation + ``` + + - The `run.py` should have a **run** function to execute the test cases. The signature should be: + + ```Python + def run(output_dir: str, subrequirement_ids: List[int]) -> Dict[int, Dict[Tuple[str, str], bool]]: + # your implementation + ``` + + The result should be a dictionary with sub-requirement ids as keys and inner dictionaries as values. The inner dictionary should map tuples of (test_case, test_case_description) to a boolean indicating the test case's success. + + `run.py` should also contain a **SUBREQUIREMENT_DESCRIPTIONS** dictionary, describing each sub-requirement. For example: + + ```Python + SUBREQUIREMENT_DESCRIPTIONS = { + 1: ("633", "Modify existing opcodes to conform to the semantics of the GC proposal when needed."), + 2: ("634", "Supporting new GC opcodes(semantics of GC MVP proposal spec)."), + 3: ("635", "Supporting new GC opcode(semantics of Binaryen GC spec)."), + } + ``` + + > PS: If anything goes wrong during the build and run process, throw an exception and let it crash, so that it can be seen by the top-level caller (shell script). + +3. Now you can test whether [the all-in-one script `test_wamr.sh`](../wamr-test-suites/test_wamr.sh) can correctly execute `new-requirement` and generate a report. + + ```shell + ./test_wamr.sh -r "new-requirement" + ``` diff --git a/tests/requirement-engineering/gc-aot/build.py b/tests/requirement-engineering/gc-aot/build.py new file mode 100644 index 00000000..1b13f4b5 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/build.py @@ -0,0 +1,74 @@ +#!/usr/bin/python3 +# +# Copyright (C) 2019 Intel Corporation. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +# + +import os + +WORK_DIR = os.getcwd() +WAMR_DIR = os.path.join(WORK_DIR, "../../../") +IWASM_DIR = os.path.join( + WORK_DIR, "../../../product-mini/platforms/linux") + + +def compile_llvm(): + print("============ compile llvm =============") + os.chdir(os.path.join(WAMR_DIR, "wamr-compiler")) + exit_status = os.system("./build_llvm.sh") + assert exit_status >> 8 == 0, "compile llvm failed, add -v for detail error output" + print("============ compile llvm successful =============") + + +def compile_wamrc(verbose: bool): + print("============ compile wamrc =============") + os.chdir(os.path.join(WAMR_DIR, "wamr-compiler")) + os.system("rm -rf build") + os.system("mkdir build") + exit_status = os.system( + f"cmake -DWAMR_BUILD_GC=1 -B build {'' if verbose else '> /dev/null 2>&1'}") + exit_status |= os.system( + f"cmake --build build -j {os.cpu_count()} {'' if verbose else '> /dev/null 2>&1'}" + ) + + assert exit_status >> 8 == 0, "compile wamrc failed, add -v for detail error output" + print("============ compile wamrc successful =============") + + +def compile_iwasm(verbose: bool): + print("============ compile iwasm =============") + os.chdir(IWASM_DIR) + os.system("rm -rf build") + os.system("mkdir build") + exit_status = os.system( + f"cmake -DWAMR_BUILD_AOT=1 -DWAMR_BUILD_GC=1 -DWAMR_BUILD_SPEC_TEST=1 -B build {'' if verbose else '> /dev/null 2>&1'}" + ) + exit_status |= os.system( + f"cmake --build build -j {os.cpu_count()} {'' if verbose else '> /dev/null 2>&1'}" + ) + os.chdir(WORK_DIR) + + assert exit_status >> 8 == 0, "compile iwasm failed, add -v for detail error output" + print("============ compile iwasm successful =============") + + +def compile_spec_interpreter(): + print("============ compile spec interpreter =============") + + os.chdir(WORK_DIR) + exit_status = os.system("./build_spec_interpreter.sh") + + assert exit_status >> 8 == 0, "compile spec interpreter failed." + print("============ compile spec interpreter successful =============") + + +def build(verbose: bool) -> None: + compile_llvm() + compile_wamrc(verbose) + compile_iwasm(verbose) + compile_spec_interpreter() + return + + +if __name__ == "__main__": + build(True) diff --git a/tests/requirement-engineering/gc-aot/build_spec_interpreter.sh b/tests/requirement-engineering/gc-aot/build_spec_interpreter.sh new file mode 100755 index 00000000..48d6343b --- /dev/null +++ b/tests/requirement-engineering/gc-aot/build_spec_interpreter.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash +# +# Copyright (C) 2019 Intel Corporation. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +# + +rm -fr spec +# check spec test cases for GC +git clone -b main --single-branch https://github.com/WebAssembly/gc.git spec +pushd spec + +git restore . && git clean -ffd . +# Reset to commit: "[test] Unify the error message." +git reset --hard 0caaadc65b5e1910512d8ae228502edcf9d60390 +git apply ../../../wamr-test-suites/spec-test-script/gc_ignore_cases.patch + +# Set OCaml compiler environment +eval $(opam config env) + +echo "compile the reference intepreter" +pushd interpreter +make +popd \ No newline at end of file diff --git a/tests/requirement-engineering/gc-aot/run.py b/tests/requirement-engineering/gc-aot/run.py new file mode 100755 index 00000000..ffd3cdfc --- /dev/null +++ b/tests/requirement-engineering/gc-aot/run.py @@ -0,0 +1,103 @@ +#!/usr/bin/python3 +# +# Copyright (C) 2019 Intel Corporation. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +# + +import os +import argparse +from typing import List, Dict, Tuple +import json + +WORK_DIR = os.getcwd() +WAMR_DIR = os.path.join(WORK_DIR, "../../..") +IWASM_CMD = os.path.join( + WORK_DIR, "../../../product-mini/platforms/linux/build/iwasm") +WAMRC_CMD = os.path.join(WORK_DIR, "../../../wamr-compiler/build/wamrc") + +SUBREQUIREMENT_DESCRIPTIONS = { + 1: ("633", "Modify existing opcodes to conform to the semantics of the GC proposal when needed."), + 2: ("634", "Supporting new GC opcodes(semantics of GC MVP proposal spec)."), + 3: ("635", "Supporting new GC opcode(semantics of Binaryen GC spec)."), +} + + +def test_subrequirement(id: int) -> Dict[Tuple[str, str], bool]: + print(f"\n============> test gc aot requirement: {id}") + + test_cases = {} + result = {} + + with open('test_cases.json') as config_file: + config = json.load(config_file) + for req in config["sub-requirements"]: + if req['req_id'] == id: + test_cases = req['cases'] + break + + for case in test_cases: + print(case) + print(f"{case['name']}.aot") + exit_status = os.system( + f"python runtest.py --aot --wast2wasm spec/interpreter/wasm --interpreter {IWASM_CMD} --aot-compiler {WAMRC_CMD} --gc wasm-apps/{case['name']}.wast" + ) + + if exit_status == 0: + result[case['name'], case['description']] = True + else: + result[case['name'], case['description']] = False + + return result + + +def run( + output_dir: str, subrequirement_ids: List[int] +) -> Dict[int, Dict[Tuple[str, str], bool]]: + # key: value -> subrequirement id: dict[tuple(test_case_name, test_case_description), is_success] + result_dict: Dict[int, Dict[Tuple[str, str], bool]] = {} + + # Default run all subrequirement + if not subrequirement_ids: + subrequirement_ids = [1, 2, 3] + + for subrequirement_id in subrequirement_ids: + if subrequirement_id not in SUBREQUIREMENT_DESCRIPTIONS.keys(): + print( + f"Subrequirement id invalid! It should be a value in {[_ for _ in SUBREQUIREMENT_DESCRIPTIONS.keys()]}" + ) + continue + result_dict[subrequirement_id] = test_subrequirement(subrequirement_id) + + return result_dict + + +if __name__ == "__main__": + print("============> test GC AOT") + + # Create the parser + parser = argparse.ArgumentParser( + description="A script to process sub-requirement ids, run corresponding test cases, and compile wamrc, iwasm if requested." + ) + + # The argparse module handles -h and --help by default, no needs to add it + # Add an output option `-o` as a flag that, when specified, sets the variable to True + parser.add_argument( + "-o", + "--output", + type=str, + required=False, + help="Specify the output file name. If provided, the script will write the results to .csv", + ) + + # Add positional arguments for integers + parser.add_argument( + "integers", + metavar="N", + type=int, + nargs="*", + help="an integer for the sub-requirement ids", + ) + # Parse arguments + args = parser.parse_args() + + run(args.output, args.integers) diff --git a/tests/requirement-engineering/gc-aot/runtest.py b/tests/requirement-engineering/gc-aot/runtest.py new file mode 100755 index 00000000..054fdf61 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/runtest.py @@ -0,0 +1,1589 @@ +#!/usr/bin/env python +# +# Copyright (C) 2019 Intel Corporation. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +# + +from __future__ import print_function +import platform + +import argparse +import array +import atexit +import math +import os +import re +import shutil +import struct +import subprocess +import sys +import tempfile +import time +import threading +import traceback +from select import select +from queue import Queue +from subprocess import PIPE, STDOUT, Popen +from typing import BinaryIO, Optional, Tuple + +if sys.version_info[0] == 2: + IS_PY_3 = False +else: + IS_PY_3 = True + +test_aot = False +# Available targets: +# "aarch64" "aarch64_vfp" "armv7" "armv7_vfp" "thumbv7" "thumbv7_vfp" +# "riscv32" "riscv32_ilp32f" "riscv32_ilp32d" "riscv64" "riscv64_lp64f" "riscv64_lp64d" +test_target = "x86_64" + +debug_file = None +log_file = None + +# to save the register module with self-define name +temp_file_repo = [] + +# to save the mapping of module files in /tmp by name +temp_module_table = {} + +# AOT compilation options mapping +aot_target_options_map = { + "i386": ["--target=i386"], + "x86_32": ["--target=i386"], + "x86_64": ["--target=x86_64", "--cpu=skylake"], + "aarch64": ["--target=aarch64", "--target-abi=eabi", "--cpu=cortex-a53"], + "aarch64_vfp": ["--target=aarch64", "--target-abi=gnueabihf", "--cpu=cortex-a53"], + "armv7": ["--target=armv7", "--target-abi=eabi", "--cpu=cortex-a9", "--cpu-features=-neon"], + "armv7_vfp": ["--target=armv7", "--target-abi=gnueabihf", "--cpu=cortex-a9"], + "thumbv7": ["--target=thumbv7", "--target-abi=eabi", "--cpu=cortex-a9", "--cpu-features=-neon,-vfpv3"], + "thumbv7_vfp": ["--target=thumbv7", "--target-abi=gnueabihf", "--cpu=cortex-a9", "--cpu-features=-neon"], + "riscv32": ["--target=riscv32", "--target-abi=ilp32", "--cpu=generic-rv32", "--cpu-features=+m,+a,+c"], + "riscv32_ilp32f": ["--target=riscv32", "--target-abi=ilp32f", "--cpu=generic-rv32", "--cpu-features=+m,+a,+c,+f"], + "riscv32_ilp32d": ["--target=riscv32", "--target-abi=ilp32d", "--cpu=generic-rv32", "--cpu-features=+m,+a,+c,+f,+d"], + "riscv64": ["--target=riscv64", "--target-abi=lp64", "--cpu=generic-rv64", "--cpu-features=+m,+a,+c"], + "riscv64_lp64f": ["--target=riscv64", "--target-abi=lp64f", "--cpu=generic-rv64", "--cpu-features=+m,+a,+c,+f"], + "riscv64_lp64d": ["--target=riscv64", "--target-abi=lp64d", "--cpu=generic-rv64", "--cpu-features=+m,+a,+c,+f,+d"], +} + + +def debug(data): + if debug_file: + debug_file.write(data) + debug_file.flush() + + +def log(data, end='\n'): + if log_file: + log_file.write(data + end) + log_file.flush() + print(data, end=end) + sys.stdout.flush() + + +def create_tmp_file(suffix: str) -> str: + with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp_file: + return tmp_file.name + + +# TODO: do we need to support '\n' too + +if platform.system().find("CYGWIN_NT") >= 0: + # TODO: this is weird, is this really right on Cygwin? + sep = "\n\r\n" +else: + sep = "\r\n" +rundir = None + + +class AsyncStreamReader: + def __init__(self, stream: BinaryIO) -> None: + self._queue = Queue() + self._reader_thread = threading.Thread( + daemon=True, + target=AsyncStreamReader._stdout_reader, + args=(self._queue, stream)) + self._reader_thread.start() + + def read(self) -> Optional[bytes]: + return self._queue.get() + + def cleanup(self) -> None: + self._reader_thread.join() + + @staticmethod + def _stdout_reader(queue: Queue, stdout: BinaryIO) -> None: + while True: + try: + queue.put(stdout.read(1)) + except ValueError as e: + if stdout.closed: + queue.put(None) + break + raise e + + +class Runner(): + def __init__(self, args, no_pty=False): + self.no_pty = no_pty + + # Cleanup child process on exit + atexit.register(self.cleanup) + + self.process = None + env = os.environ + env['TERM'] = 'dumb' + env['INPUTRC'] = '/dev/null' + env['PERL_RL'] = 'false' + if no_pty: + self.process = Popen(args, bufsize=0, + stdin=PIPE, stdout=PIPE, stderr=STDOUT, + env=env) + self.stdin = self.process.stdin + self.stdout = self.process.stdout + else: + import fcntl + # Pseudo-TTY and terminal manipulation + import pty + import termios + # Use tty to setup an interactive environment + master, slave = pty.openpty() + + # Set terminal size large so that readline will not send + # ANSI/VT escape codes when the lines are long. + buf = array.array('h', [100, 200, 0, 0]) + fcntl.ioctl(master, termios.TIOCSWINSZ, buf, True) + + self.process = Popen(args, bufsize=0, + stdin=slave, stdout=slave, stderr=STDOUT, + preexec_fn=os.setsid, + env=env) + # Now close slave so that we will get an exception from + # read when the child exits early + # http://stackoverflow.com/questions/11165521 + os.close(slave) + self.stdin = os.fdopen(master, 'r+b', 0) + self.stdout = self.stdin + + if platform.system().lower() == "windows": + self._stream_reader = AsyncStreamReader(self.stdout) + else: + self._stream_reader = None + + self.buf = "" + + def _read_stdout_byte(self) -> Tuple[bool, Optional[bytes]]: + if self._stream_reader: + return True, self._stream_reader.read() + else: + # select doesn't work on file descriptors on Windows. + # however, this method is much faster than using + # queue, so we keep it for non-windows platforms. + [outs, _, _] = select([self.stdout], [], [], 1) + if self.stdout in outs: + return True, self.stdout.read(1) + else: + return False, None + + def read_to_prompt(self, prompts, timeout): + wait_until = time.time() + timeout + while time.time() < wait_until: + has_value, read_byte = self._read_stdout_byte() + if not has_value: + continue + if not read_byte: + # EOF on macOS ends up here. + break + read_byte = read_byte.decode('utf-8') if IS_PY_3 else read_byte + + debug(read_byte) + if self.no_pty: + self.buf += read_byte.replace('\n', '\r\n') + else: + self.buf += read_byte + self.buf = self.buf.replace('\r\r', '\r') + + # filter the prompts + for prompt in prompts: + pattern = re.compile(prompt) + match = pattern.search(self.buf) + if match: + end = match.end() + buf = self.buf[0:end-len(prompt)] + self.buf = self.buf[end:] + return buf + return None + + def writeline(self, str): + str_to_write = str + '\n' + str_to_write = bytes( + str_to_write, 'utf-8') if IS_PY_3 else str_to_write + + self.stdin.write(str_to_write) + + def cleanup(self): + atexit.unregister(self.cleanup) + + if self.process: + try: + self.writeline("__exit__") + time.sleep(.020) + self.process.kill() + except OSError: + pass + except IOError: + pass + self.process = None + self.stdin.close() + if self.stdin != self.stdout: + self.stdout.close() + self.stdin = None + self.stdout = None + if not IS_PY_3: + sys.exc_clear() + if self._stream_reader: + self._stream_reader.cleanup() + + +def assert_prompt(runner, prompts, timeout, is_need_execute_result): + # Wait for the initial prompt + header = runner.read_to_prompt(prompts, timeout=timeout) + if not header and is_need_execute_result: + log(" ---------- will terminate cause the case needs result while there is none inside of buf. ----------") + sys.exit(1) + if not header == None: + if header: + log("Started with:\n%s" % header) + else: + log("Did not one of following prompt(s): %s" % repr(prompts)) + log(" Got : %s" % repr(r.buf)) + sys.exit(1) + + +# WebAssembly specific + +parser = argparse.ArgumentParser( + description="Run a test file against a WebAssembly interpreter") +parser.add_argument('--wast2wasm', type=str, + default=os.environ.get("WAST2WASM", "wast2wasm"), + help="Path to wast2wasm program") +parser.add_argument('--interpreter', type=str, + default=os.environ.get("IWASM_CMD", "iwasm"), + help="Path to WebAssembly interpreter") +parser.add_argument('--aot-compiler', type=str, + default=os.environ.get("WAMRC_CMD", "wamrc"), + help="Path to WebAssembly AoT compiler") + +parser.add_argument('--no_cleanup', action='store_true', + help="Keep temporary *.wasm files") + +parser.add_argument('--rundir', + help="change to the directory before running tests") +parser.add_argument('--start-timeout', default=30, type=int, + help="default timeout for initial prompt") +parser.add_argument('--test-timeout', default=20, type=int, + help="default timeout for each individual test action") +parser.add_argument('--no-pty', action='store_true', + help="Use direct pipes instead of pseudo-tty") +parser.add_argument('--log-file', type=str, + help="Write messages to the named file in addition the screen") +parser.add_argument('--log-dir', type=str, + help="The log directory to save the case file if test failed") +parser.add_argument('--debug-file', type=str, + help="Write all test interaction the named file") + +parser.add_argument('test_file', type=argparse.FileType('r'), + help="a WebAssembly *.wast test file") + +parser.add_argument('--aot', action='store_true', + help="Test with AOT") + +parser.add_argument('--target', type=str, + default="x86_64", + help="Set running target") + +parser.add_argument('--sgx', action='store_true', + help="Test SGX") + +parser.add_argument('--simd', default=False, action='store_true', + help="Enable SIMD") + +parser.add_argument('--xip', default=False, action='store_true', + help="Enable XIP") + +parser.add_argument('--multi-module', default=False, action='store_true', + help="Enable Multi-thread") + +parser.add_argument('--multi-thread', default=False, action='store_true', + help="Enable Multi-thread") + +parser.add_argument('--gc', default=False, action='store_true', + help='Test with GC') + +parser.add_argument('--qemu', default=False, action='store_true', + help="Enable QEMU") + +parser.add_argument('--qemu-firmware', default='', + help="Firmware required by qemu") + +parser.add_argument('--verbose', default=False, action='store_true', + help='show more logs') + +# regex patterns of tests to skip +C_SKIP_TESTS = () +PY_SKIP_TESTS = ( + # names.wast + 'invoke \"~!', + # conversions.wast + '18446742974197923840.0', + '18446744073709549568.0', + '9223372036854775808', + 'reinterpret_f.*nan', + # endianness + '.const 0x1.fff') + + +def read_forms(string): + forms = [] + form = "" + depth = 0 + line = 0 + pos = 0 + while pos < len(string): + # Keep track of line number + if string[pos] == '\n': + line += 1 + + # Handle top-level elements + if depth == 0: + # Add top-level comments + if string[pos:pos+2] == ";;": + end = string.find("\n", pos) + if end == -1: + end == len(string) + forms.append(string[pos:end]) + pos = end + continue + + # TODO: handle nested multi-line comments + if string[pos:pos+2] == "(;": + # Skip multi-line comment + end = string.find(";)", pos) + if end == -1: + raise Exception("mismatch multiline comment on line %d: '%s'" % ( + line, string[pos:pos+80])) + pos = end+2 + continue + + # Ignore whitespace between top-level forms + if string[pos] in (' ', '\n', '\t'): + pos += 1 + continue + + # Read a top-level form + if string[pos] == '(': + depth += 1 + if string[pos] == ')': + depth -= 1 + if depth == 0 and not form: + raise Exception("garbage on line %d: '%s'" % ( + line, string[pos:pos+80])) + form += string[pos] + if depth == 0 and form: + forms.append(form) + form = "" + pos += 1 + return forms + + +def get_module_exp_from_assert(string): + depth = 0 + pos = 0 + module = "" + exception = "" + start_record = False + result = [] + while pos < len(string): + # record from the " (module " + if string[pos:pos+7] == "(module": + start_record = True + if start_record: + if string[pos] == '(': + depth += 1 + if string[pos] == ')': + depth -= 1 + module += string[pos] + # if we get all (module ) . + if depth == 0 and module: + result.append(module) + start_record = False + # get expected exception + if string[pos] == '"': + end = string.find("\"", pos+1) + if end != -1: + end_rel = string.find("\"", end+1) + if end_rel == -1: + result.append(string[pos+1:end]) + pos += 1 + return result + + +def string_to_unsigned(number_in_string, lane_type): + if not lane_type in ['i8x16', 'i16x8', 'i32x4', 'i64x2']: + raise Exception("invalid value {} and type {} and lane_type {}".format( + number_in_string, type, lane_type)) + + number = int(number_in_string, 16) if '0x' in number_in_string else int( + number_in_string) + + if "i8x16" == lane_type: + if number < 0: + packed = struct.pack('b', number) + number = struct.unpack('B', packed)[0] + elif "i16x8" == lane_type: + if number < 0: + packed = struct.pack('h', number) + number = struct.unpack('H', packed)[0] + elif "i32x4" == lane_type: + if number < 0: + packed = struct.pack('i', number) + number = struct.unpack('I', packed)[0] + else: # "i64x2" == lane_type: + if number < 0: + packed = struct.pack('q', number) + number = struct.unpack('Q', packed)[0] + + return number + + +def cast_v128_to_i64x2(numbers, type, lane_type): + numbers = [n.replace("_", "") for n in numbers] + + if "i8x16" == lane_type: + assert (16 == len(numbers)), "{} should like {}".format( + numbers, lane_type) + # str -> int + numbers = [string_to_unsigned(n, lane_type) for n in numbers] + # i8 -> i64 + packed = struct.pack(16 * "B", *numbers) + elif "i16x8" == lane_type: + assert (8 == len(numbers)), "{} should like {}".format( + numbers, lane_type) + # str -> int + numbers = [string_to_unsigned(n, lane_type) for n in numbers] + # i16 -> i64 + packed = struct.pack(8 * "H", *numbers) + elif "i32x4" == lane_type: + assert (4 == len(numbers)), "{} should like {}".format( + numbers, lane_type) + # str -> int + numbers = [string_to_unsigned(n, lane_type) for n in numbers] + # i32 -> i64 + packed = struct.pack(4 * "I", *numbers) + elif "i64x2" == lane_type: + assert (2 == len(numbers)), "{} should like {}".format( + numbers, lane_type) + # str -> int + numbers = [string_to_unsigned(n, lane_type) for n in numbers] + # i64 -> i64 + packed = struct.pack(2 * "Q", *numbers) + elif "f32x4" == lane_type: + assert (4 == len(numbers)), "{} should like {}".format( + numbers, lane_type) + # str -> int + numbers = [parse_simple_const_w_type(n, "f32")[0] for n in numbers] + # f32 -> i64 + packed = struct.pack(4 * "f", *numbers) + elif "f64x2" == lane_type: + assert (2 == len(numbers)), "{} should like {}".format( + numbers, lane_type) + # str -> int + numbers = [parse_simple_const_w_type(n, "f64")[0] for n in numbers] + # f64 -> i64 + packed = struct.pack(2 * "d", *numbers) + else: + raise Exception("invalid value {} and type {} and lane_type {}".format( + numbers, type, lane_type)) + + assert (packed) + unpacked = struct.unpack("Q Q", packed) + return unpacked, f"[{unpacked[0]:#x} {unpacked[1]:#x}]:{lane_type}:v128" + + +def parse_simple_const_w_type(number, type): + number = number.replace('_', '') + number = re.sub(r"nan\((ind|snan)\)", "nan", number) + if type in ["i32", "i64"]: + number = int(number, 16) if '0x' in number else int(number) + return number, "0x{:x}:{}".format(number, type) \ + if number >= 0 \ + else "-0x{:x}:{}".format(0 - number, type) + elif type in ["f32", "f64"]: + if "nan:" in number: + return float('nan'), "nan:{}".format(type) + else: + number = float.fromhex(number) if '0x' in number else float(number) + return number, "{:.7g}:{}".format(number, type) + elif type == "ref.null": + if number == "func": + return "func", "func:ref.null" + elif number == "extern": + return "extern", "extern:ref.null" + elif number == "any": + return "any", "any:ref.null" + else: + raise Exception( + "invalid value {} and type {}".format(number, type)) + elif type == "ref.extern": + number = int(number, 16) if '0x' in number else int(number) + return number, "0x{:x}:ref.extern".format(number) + elif type == "ref.host": + number = int(number, 16) if '0x' in number else int(number) + return number, "0x{:x}:ref.host".format(number) + else: + raise Exception("invalid value {} and type {}".format(number, type)) + + +def parse_assertion_value(val): + """ + Parse something like: + "ref.null extern" in (assert_return (invoke "get-externref" (i32.const 0)) (ref.null extern)) + "ref.extern 1" in (assert_return (invoke "get-externref" (i32.const 1)) (ref.extern 1)) + "i32.const 0" in (assert_return (invoke "is_null-funcref" (i32.const 1)) (i32.const 0)) + + in summary: + type.const (sub-type) (val1 val2 val3 val4) ... + type.const val + ref.extern val + ref.null ref_type + ref.array + ref.struct + ref.func + ref.i31 + """ + if not val: + return None, "" + + splitted = re.split('\s+', val) + splitted = [s for s in splitted if s] + type = splitted[0].split(".")[0] + lane_type = splitted[1] if len(splitted) > 2 else "" + numbers = splitted[2:] if len(splitted) > 2 else splitted[1:] + + if type in ["i32", "i64", "f32", "f64"]: + return parse_simple_const_w_type(numbers[0], type) + elif type == "ref": + if splitted[0] in ["ref.array", "ref.struct", "ref.func", "ref.i31"]: + return splitted[0] + # need to distinguish between "ref.null" and "ref.extern" + return parse_simple_const_w_type(numbers[0], splitted[0]) + else: + return cast_v128_to_i64x2(numbers, type, lane_type) + + +def int2uint32(i): + return i & 0xffffffff + + +def int2int32(i): + val = i & 0xffffffff + if val & 0x80000000: + return val - 0x100000000 + else: + return val + + +def int2uint64(i): + return i & 0xffffffffffffffff + + +def int2int64(i): + val = i & 0xffffffffffffffff + if val & 0x8000000000000000: + return val - 0x10000000000000000 + else: + return val + + +def num_repr(i): + if isinstance(i, int) or isinstance(i, long): + return re.sub("L$", "", hex(i)) + else: + return "%.16g" % i + + +def hexpad16(i): + return "0x%04x" % i + + +def hexpad24(i): + return "0x%06x" % i + + +def hexpad32(i): + return "0x%08x" % i + + +def hexpad64(i): + return "0x%016x" % i + + +def invoke(r, args, cmd): + r.writeline(cmd) + + return r.read_to_prompt(['\r\nwebassembly> ', '\nwebassembly> '], + timeout=args.test_timeout) + + +def vector_value_comparison(out, expected): + """ + out likes ":v128" + expected likes "[number number]:v128" + """ + # print("vector value comparision {} vs {}".format(out, expected)) + + out_val, out_type = out.split(':') + # => number number + out_val = out_val[1:-1] + + expected_val, lane_type, expected_type = expected.split(':') + # [number nubmer] => number number + expected_val = expected_val[1:-1] + + assert ("v128" == out_type), "out_type should be v128" + assert ("v128" == expected_type), "expected_type should be v128" + + if out_type != expected_type: + return False + + out_val = out_val.split(" ") + expected_val = expected_val.split(" ") + + # since i64x2 + out_packed = struct.pack("QQ", int(out_val[0], 16), int(out_val[1], 16)) + expected_packed = struct.pack("QQ", + int(expected_val[0]) if not "0x" in expected_val[0] else int( + expected_val[0], 16), + int(expected_val[1]) if not "0x" in expected_val[1] else int(expected_val[1], 16)) + + if lane_type in ["i8x16", "i16x8", "i32x4", "i64x2"]: + return out_packed == expected_packed + else: + assert (lane_type in ["f32x4", "f64x2"]), "unexpected lane_type" + + if "f32x4" == lane_type: + out_unpacked = struct.unpack("ffff", out_packed) + expected_unpacked = struct.unpack("ffff", expected_packed) + else: + out_unpacked = struct.unpack("dd", out_packed) + expected_unpacked = struct.unpack("dd", expected_packed) + + out_is_nan = [math.isnan(o) for o in out_unpacked] + expected_is_nan = [math.isnan(e) for e in expected_unpacked] + if any(out_is_nan): + nan_comparision = [o == e for o, e in zip( + out_is_nan, expected_is_nan)] + if all(nan_comparision): + print(f"Pass NaN comparision") + return True + + # print(f"compare {out_unpacked} and {expected_unpacked}") + result = [o == e for o, e in zip(out_unpacked, expected_unpacked)] + if not all(result): + result = [ + "{:.7g}".format(o) == "{:.7g}".format(e) + for o, e in zip(out_unpacked, expected_packed) + ] + + return all(result) + + +def simple_value_comparison(out, expected): + """ + compare out of simple types which may like val:i32, val:f64 and so on + """ + if expected == "2.360523e+13:f32" and out == "2.360522e+13:f32": + # one case in float_literals.wast, due to float precision of python + return True + + if expected == "1.797693e+308:f64" and out == "inf:f64": + # one case in float_misc.wast: + # (assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) + # (f64.const 0x1.fffffffffffffp+969)) + # (f64.const 0x1.fffffffffffffp+1023)) + # the add result in x86_32 is inf + return True + + out_val, out_type = out.split(':') + expected_val, expected_type = expected.split(':') + + if not out_type == expected_type: + return False + + out_val, _ = parse_simple_const_w_type(out_val, out_type) + expected_val, _ = parse_simple_const_w_type(expected_val, expected_type) + + if out_val == expected_val \ + or (math.isnan(out_val) and math.isnan(expected_val)): + return True + + if "i32" == expected_type: + out_val_binary = struct.pack('I', out_val) if out_val > 0 \ + else struct.pack('i', out_val) + expected_val_binary = struct.pack('I', expected_val) \ + if expected_val > 0 \ + else struct.pack('i', expected_val) + elif "i64" == expected_type: + out_val_binary = struct.pack('Q', out_val) if out_val > 0 \ + else struct.pack('q', out_val) + expected_val_binary = struct.pack('Q', expected_val) \ + if expected_val > 0 \ + else struct.pack('q', expected_val) + elif "f32" == expected_type: + out_val_binary = struct.pack('f', out_val) + expected_val_binary = struct.pack('f', expected_val) + elif "f64" == expected_type: + out_val_binary = struct.pack('d', out_val) + expected_val_binary = struct.pack('d', expected_val) + elif "ref.extern" == expected_type: + out_val_binary = out_val + expected_val_binary = expected_val + elif "ref.host" == expected_type: + out_val_binary = out_val + expected_val_binary = expected_val + else: + assert (0), "unknown 'expected_type' {}".format(expected_type) + + if out_val_binary == expected_val_binary: + return True + + if expected_type in ["f32", "f64"]: + # compare with a lower precision + out_str = "{:.7g}".format(out_val) + expected_str = "{:.7g}".format(expected_val) + if out_str == expected_str: + return True + + return False + + +def value_comparison(out, expected): + if out == expected: + return True + + if not expected: + return False + + if not out in ["ref.array", "ref.struct", "ref.func", "ref.any", "ref.i31"]: + assert ( + ':' in out), "out should be in a form likes numbers:type, but {}".format(out) + if not expected in ["ref.array", "ref.struct", "ref.func", "ref.any", "ref.i31"]: + assert (':' in expected), "expected should be in a form likes numbers:type, but {}".format( + expected) + + if 'v128' in out: + return vector_value_comparison(out, expected) + else: + return simple_value_comparison(out, expected) + + +def is_result_match_expected(out, expected): + # compare value instead of comparing strings of values + return value_comparison(out, expected) + + +def test_assert(r, opts, mode, cmd, expected): + log("Testing(%s) %s = %s" % (mode, cmd, expected)) + out = invoke(r, opts, cmd) + if '\n' in out or ' ' in out: + outs = [''] + out.split('\n')[1:] + out = outs[-1] + + if mode == 'trap': + o = re.sub('^Exception: ', '', out) + e = re.sub('^Exception: ', '', expected) + if o.find(e) >= 0 or e.find(o) >= 0: + return True + + if mode == 'exhaustion': + o = re.sub('^Exception: ', '', out) + expected = 'Exception: stack overflow' + e = re.sub('^Exception: ', '', expected) + if o.find(e) >= 0 or e.find(o) >= 0: + return True + + # 0x9:i32,-0x1:i32 -> ['0x9:i32', '-0x1:i32'] + expected_list = re.split(',', expected) + out_list = re.split(',', out) + if len(expected_list) != len(out_list): + raise Exception( + "Failed:\n Results count incorrect:\n expected: '%s'\n got: '%s'" % (expected, out)) + for i in range(len(expected_list)): + if not is_result_match_expected(out_list[i], expected_list[i]): + raise Exception("Failed:\n Result %d incorrect:\n expected: '%s'\n got: '%s'" % ( + i, expected_list[i], out_list[i])) + + return True + + +def test_assert_return(r, opts, form): + """ + m. to search a pattern like (assert_return (invoke function_name ... ) ...) + n. to search a pattern like (assert_return (invoke $module_name function_name ... ) ...) + """ + # params, return + m = re.search( + '^\(assert_return\s+\(invoke\s+"((?:[^"]|\\\")*)"\s+(\(.*\))\s*\)\s*(\(.*\))\s*\)\s*$', form, re.S) + # judge if assert_return cmd includes the module name + n = re.search( + '^\(assert_return\s+\(invoke\s+\$((?:[^\s])*)\s+"((?:[^"]|\\\")*)"\s+(\(.*\))\s*\)\s*(\(.*\))\s*\)\s*$', form, re.S) + + # print("assert_return with {}".format(form)) + + if not m: + # no params, return + m = re.search( + '^\(assert_return\s+\(invoke\s+"((?:[^"]|\\\")*)"\s*\)\s+()(\(.*\))\s*\)\s*$', form, re.S) + if not m: + # params, no return + m = re.search( + '^\(assert_return\s+\(invoke\s+"([^"]*)"\s+(\(.*\))()\s*\)\s*\)\s*$', form, re.S) + if not m: + # no params, no return + m = re.search( + '^\(assert_return\s+\(invoke\s+"([^"]*)"\s*()()\)\s*\)\s*$', form, re.S) + if not m: + # params, return + if not n: + # no params, return + n = re.search( + '^\(assert_return\s+\(invoke\s+\$((?:[^\s])*)\s+"((?:[^"]|\\\")*)"\s*\)\s+()(\(.*\))\s*\)\s*$', form, re.S) + if not n: + # params, no return + n = re.search( + '^\(assert_return\s+\(invoke\s+\$((?:[^\s])*)\s+"([^"]*)"\s+(\(.*\))()\s*\)\s*\)\s*$', form, re.S) + if not n: + # no params, no return + n = re.search( + '^\(assert_return\s+\(invoke\s+\$((?:[^\s])*)\s+"([^"]*)"*()()\)\s*\)\s*$', form, re.S) + if not m and not n: + if re.search('^\(assert_return\s+\(get.*\).*\)$', form, re.S): + log("ignoring assert_return get") + return + else: + raise Exception("unparsed assert_return: '%s'" % form) + if m and not n: + func = m.group(1) + if ' ' in func: + func = func.replace(' ', '\\') + + if m.group(2) == '': + args = [] + else: + # args = [re.split(' +', v)[1].replace('_', "") for v in re.split("\)\s*\(", m.group(2)[1:-1])] + # split arguments with ')spaces(', remove leading and tailing ) and ( + args_type_and_value = re.split(r'\)\s+\(', m.group(2)[1:-1]) + args_type_and_value = [s.replace('_', '') + for s in args_type_and_value] + # args are in two forms: + # f32.const -0x1.000001fffffffffffp-50 + # v128.const i32x4 0 0 0 0 + args = [] + for arg in args_type_and_value: + # remove leading and tailing spaces, it might confuse following assertions + arg = arg.strip() + splitted = re.split('\s+', arg) + splitted = [s for s in splitted if s] + + if splitted[0] in ["i32.const", "i64.const"]: + assert (2 == len(splitted) + ), "{} should have two parts".format(splitted) + # in wast 01234 means 1234 + # in c 0123 means 83 in oct + number, _ = parse_simple_const_w_type( + splitted[1], splitted[0][:3]) + args.append(str(number)) + elif splitted[0] in ["f32.const", "f64.const"]: + # let strtof or strtod handle original arguments + assert (2 == len(splitted) + ), "{} should have two parts".format(splitted) + args.append(splitted[1]) + elif "v128.const" == splitted[0]: + assert (len(splitted) > 2), "{} should have more than two parts".format( + splitted) + numbers, _ = cast_v128_to_i64x2( + splitted[2:], 'v128', splitted[1]) + + assert (len(numbers) == + 2), "has to reform arguments into i64x2" + args.append(f"{numbers[0]:#x}\{numbers[1]:#x}") + elif "ref.null" == splitted[0]: + args.append("null") + elif "ref.extern" == splitted[0]: + number, _ = parse_simple_const_w_type( + splitted[1], splitted[0]) + args.append(str(number)) + elif "ref.host" == splitted[0]: + number, _ = parse_simple_const_w_type( + splitted[1], splitted[0]) + args.append(str(number)) + else: + assert (0), "an unkonwn parameter type" + + if m.group(3) == '': + returns = [] + else: + returns = re.split("\)\s*\(", m.group(3)[1:-1]) + # processed numbers in strings + if len(returns) == 1 and returns[0] in ["ref.array", "ref.struct", "ref.i31", + "ref.eq", "ref.any", "ref.extern", + "ref.func", "ref.null"]: + expected = [returns[0]] + elif len(returns) == 1 and returns[0] in ["func:ref.null", "any:ref.null", + "extern:ref.null"]: + expected = [returns[0]] + else: + expected = [parse_assertion_value(v)[1] for v in returns] + expected = ",".join(expected) + + test_assert(r, opts, "return", "%s %s" % + (func, " ".join(args)), expected) + elif not m and n: + module = temp_module_table[n.group(1)].split(".wasm")[0] + # assume the cmd is (assert_return(invoke $ABC "func")). + # run the ABC.wasm firstly + if test_aot: + r = compile_wasm_to_aot( + module+".wasm", module+".aot", True, opts, r) + try: + assert_prompt(r, ['Compile success'], + opts.start_timeout, False) + except: + _, exc, _ = sys.exc_info() + log("Run wamrc failed:\n got: '%s'" % r.buf) + ret_code = 1 + sys.exit(1) + r = run_wasm_with_repl(module+".wasm", module + + ".aot" if test_aot else module, opts, r) + # Wait for the initial prompt + try: + assert_prompt(r, ['webassembly> '], opts.start_timeout, False) + except: + _, exc, _ = sys.exc_info() + raise Exception("Failed:\n expected: '%s'\n got: '%s'" % + (repr(exc), r.buf)) + func = n.group(2) + if ' ' in func: + func = func.replace(' ', '\\') + + if n.group(3) == '': + args = [] + else: + # convert (ref.null extern/func) into (ref.null null) + n1 = n.group(3).replace("(ref.null extern)", "(ref.null null)") + n1 = n1.replace("ref.null func)", "(ref.null null)") + args = [re.split(' +', v)[1] + for v in re.split("\)\s*\(", n1[1:-1])] + + _, expected = parse_assertion_value(n.group(4)[1:-1]) + test_assert(r, opts, "return", "%s %s" % + (func, " ".join(args)), expected) + + +def test_assert_trap(r, opts, form): + # params + m = re.search( + '^\(assert_trap\s+\(invoke\s+"([^"]*)"\s+(\(.*\))\s*\)\s*"([^"]+)"\s*\)\s*$', form) + # judge if assert_return cmd includes the module name + n = re.search( + '^\(assert_trap\s+\(invoke\s+\$((?:[^\s])*)\s+"([^"]*)"\s+(\(.*\))\s*\)\s*"([^"]+)"\s*\)\s*$', form, re.S) + if not m: + # no params + m = re.search( + '^\(assert_trap\s+\(invoke\s+"([^"]*)"\s*()\)\s*"([^"]+)"\s*\)\s*$', form) + if not m: + if not n: + # no params + n = re.search( + '^\(assert_trap\s+\(invoke\s+\$((?:[^\s])*)\s+"([^"]*)"\s*()\)\s*"([^"]+)"\s*\)\s*$', form, re.S) + if not m and not n: + raise Exception("unparsed assert_trap: '%s'" % form) + + if m and not n: + func = m.group(1) + if m.group(2) == '': + args = [] + else: + # convert (ref.null extern/func) into (ref.null null) + m1 = m.group(2).replace("(ref.null extern)", "(ref.null null)") + m1 = m1.replace("ref.null func)", "(ref.null null)") + args = [re.split(' +', v)[1] + for v in re.split("\)\s*\(", m1[1:-1])] + + expected = "Exception: %s" % m.group(3) + test_assert(r, opts, "trap", "%s %s" % + (func, " ".join(args)), expected) + + elif not m and n: + module = n.group(1) + module = tempfile.gettempdir() + "/" + module + + # will trigger the module named in assert_return(invoke $ABC). + # run the ABC.wasm firstly + if test_aot: + r = compile_wasm_to_aot( + module+".wasm", module+".aot", True, opts, r) + try: + assert_prompt(r, ['Compile success'], + opts.start_timeout, False) + except: + _, exc, _ = sys.exc_info() + log("Run wamrc failed:\n got: '%s'" % r.buf) + ret_code = 1 + sys.exit(1) + r = run_wasm_with_repl(module+".wasm", module + + ".aot" if test_aot else module, opts, r) + # Wait for the initial prompt + try: + assert_prompt(r, ['webassembly> '], opts.start_timeout, False) + except: + _, exc, _ = sys.exc_info() + raise Exception("Failed:\n expected: '%s'\n got: '%s'" % + (repr(exc), r.buf)) + + func = n.group(2) + if n.group(3) == '': + args = [] + else: + args = [re.split(' +', v)[1] + for v in re.split("\)\s*\(", n.group(3)[1:-1])] + expected = "Exception: %s" % n.group(4) + test_assert(r, opts, "trap", "%s %s" % + (func, " ".join(args)), expected) + + +def test_assert_exhaustion(r, opts, form): + # params + m = re.search( + '^\(assert_exhaustion\s+\(invoke\s+"([^"]*)"\s+(\(.*\))\s*\)\s*"([^"]+)"\s*\)\s*$', form) + if not m: + # no params + m = re.search( + '^\(assert_exhaustion\s+\(invoke\s+"([^"]*)"\s*()\)\s*"([^"]+)"\s*\)\s*$', form) + if not m: + raise Exception("unparsed assert_exhaustion: '%s'" % form) + func = m.group(1) + if m.group(2) == '': + args = [] + else: + args = [re.split(' +', v)[1] + for v in re.split("\)\s*\(", m.group(2)[1:-1])] + expected = "Exception: %s\n" % m.group(3) + test_assert(r, opts, "exhaustion", "%s %s" % + (func, " ".join(args)), expected) + + +def do_invoke(r, opts, form): + # params + m = re.search('^\(invoke\s+"([^"]+)"\s+(\(.*\))\s*\)\s*$', form) + if not m: + # no params + m = re.search('^\(invoke\s+"([^"]+)"\s*()\)\s*$', form) + if not m: + raise Exception("unparsed invoke: '%s'" % form) + func = m.group(1) + + if ' ' in func: + func = func.replace(' ', '\\') + + if m.group(2) == '': + args = [] + else: + args = [re.split(' +', v)[1] + for v in re.split("\)\s*\(", m.group(2)[1:-1])] + + log("Invoking %s(%s)" % ( + func, ", ".join([str(a) for a in args]))) + + invoke(r, opts, "%s %s" % (func, " ".join(args))) + + +def skip_test(form, skip_list): + for s in skip_list: + if re.search(s, form): + return True + return False + + +def compile_wast_to_wasm(form, wast_tempfile, wasm_tempfile, opts): + log("Writing WAST module to '%s'" % wast_tempfile) + with open(wast_tempfile, 'w') as file: + file.write(form) + log("Compiling WASM to '%s'" % wasm_tempfile) + + # default arguments + if opts.gc: + cmd = [opts.wast2wasm, "-u", "-d", wast_tempfile, "-o", wasm_tempfile] + else: + cmd = [opts.wast2wasm, "--enable-thread", "--no-check", + wast_tempfile, "-o", wasm_tempfile] + + # remove reference-type and bulk-memory enabling options since a WABT + # commit 30c1e983d30b33a8004b39fd60cbd64477a7956c + # Enable reference types by default (#1729) + + log("Running: %s" % " ".join(cmd)) + try: + subprocess.check_call(cmd) + except subprocess.CalledProcessError as e: + print(str(e)) + return False + + return True + + +def compile_wasm_to_aot(wasm_tempfile, aot_tempfile, runner, opts, r, output='default'): + log("Compiling '%s' to '%s'" % (wasm_tempfile, aot_tempfile)) + cmd = [opts.aot_compiler] + + if test_target in aot_target_options_map: + cmd += aot_target_options_map[test_target] + + if opts.sgx: + cmd.append("-sgx") + + if not opts.simd: + cmd.append("--disable-simd") + + if opts.xip: + cmd.append("--enable-indirect-mode") + cmd.append("--disable-llvm-intrinsics") + + if opts.multi_thread: + cmd.append("--enable-multi-thread") + + if opts.gc: + cmd.append("--enable-gc") + cmd.append("--enable-tail-call") + + if output == 'object': + cmd.append("--format=object") + elif output == 'ir': + cmd.append("--format=llvmir-opt") + + # disable llvm link time optimization as it might convert + # code of tail call into code of dead loop, and stack overflow + # exception isn't thrown in several cases + cmd.append("--disable-llvm-lto") + + # Bounds checks is disabled by default for 64-bit targets, to + # use the hardware based bounds checks. But it is not supported + # in QEMU with NuttX. + # Enable bounds checks explicitly for all targets if running in QEMU. + if opts.qemu: + cmd.append("--bounds-checks=1") + + # RISCV64 requires -mcmodel=medany, which can be set by --size-level=1 + if test_target.startswith("riscv64"): + cmd.append("--size-level=1") + + cmd += ["-o", aot_tempfile, wasm_tempfile] + + log("Running: %s" % " ".join(cmd)) + if not runner: + subprocess.check_call(cmd) + else: + if (r != None): + r.cleanup() + r = Runner(cmd, no_pty=opts.no_pty) + return r + + +def run_wasm_with_repl(wasm_tempfile, aot_tempfile, opts, r): + tmpfile = aot_tempfile if test_aot else wasm_tempfile + log("Starting interpreter for module '%s'" % tmpfile) + + cmd_iwasm = [opts.interpreter, "--heap-size=0", + "-v=5" if opts.verbose else "-v=0", "--repl", tmpfile] + + if opts.multi_module: + cmd_iwasm.insert(1, "--module-path=" + + (tempfile.gettempdir() if not opts.qemu else "/tmp")) + + if opts.qemu: + if opts.qemu_firmware == '': + raise Exception("QEMU firmware missing") + + if opts.target.startswith("aarch64"): + cmd = "qemu-system-aarch64 -cpu cortex-a53 -nographic -machine virt,virtualization=on,gic-version=3 -net none -chardev stdio,id=con,mux=on -serial chardev:con -mon chardev=con,mode=readline -kernel".split() + cmd.append(opts.qemu_firmware) + elif opts.target.startswith("thumbv7"): + cmd = "qemu-system-arm -semihosting -M sabrelite -m 1024 -smp 1 -nographic -kernel".split() + cmd.append(opts.qemu_firmware) + elif opts.target.startswith("riscv32"): + cmd = "qemu-system-riscv32 -semihosting -M virt,aclint=on -cpu rv32 -smp 1 -nographic -bios none -kernel".split() + cmd.append(opts.qemu_firmware) + elif opts.target.startswith("riscv64"): + cmd = "qemu-system-riscv64 -semihosting -M virt,aclint=on -cpu rv64 -smp 1 -nographic -bios none -kernel".split() + cmd.append(opts.qemu_firmware) + else: + raise Exception("Unknwon target for QEMU: %s" % opts.target) + + else: + cmd = cmd_iwasm + + log("Running: %s" % " ".join(cmd)) + if (r != None): + r.cleanup() + r = Runner(cmd, no_pty=opts.no_pty) + + if opts.qemu: + r.read_to_prompt(['nsh> '], 10) + r.writeline( + "mount -t hostfs -o fs={} /tmp".format(tempfile.gettempdir())) + r.read_to_prompt(['nsh> '], 10) + r.writeline(" ".join(cmd_iwasm)) + + return r + + +def create_tmpfiles(wast_name): + tempfiles = [] + + tempfiles.append(create_tmp_file(".wast")) + tempfiles.append(create_tmp_file(".wasm")) + if test_aot: + tempfiles.append(create_tmp_file(".aot")) + + # add these temp file to temporal repo, will be deleted when finishing the test + temp_file_repo.extend(tempfiles) + return tempfiles + + +def test_assert_with_exception(form, wast_tempfile, wasm_tempfile, aot_tempfile, opts, r, loadable=True): + details_inside_ast = get_module_exp_from_assert(form) + log("module is ....'%s'" % details_inside_ast[0]) + log("exception is ....'%s'" % details_inside_ast[1]) + # parse the module + module = details_inside_ast[0] + expected = details_inside_ast[1] + + if not compile_wast_to_wasm(module, wast_tempfile, wasm_tempfile, opts): + raise Exception("compile wast to wasm failed") + + if test_aot: + r = compile_wasm_to_aot(wasm_tempfile, aot_tempfile, True, opts, r) + try: + assert_prompt(r, ['Compile success'], opts.start_timeout, True) + except: + _, exc, _ = sys.exc_info() + if (r.buf.find(expected) >= 0): + log("Out exception includes expected one, pass:") + log(" Expected: %s" % expected) + log(" Got: %s" % r.buf) + return + else: + log("Run wamrc failed:\n expected: '%s'\n got: '%s'" % + (expected, r.buf)) + ret_code = 1 + sys.exit(1) + + r = run_wasm_with_repl( + wasm_tempfile, aot_tempfile if test_aot else None, opts, r) + + # Some module couldn't load so will raise an error directly, so shell prompt won't show here + + if loadable: + # Wait for the initial prompt + try: + assert_prompt(r, ['webassembly> '], opts.start_timeout, True) + except: + _, exc, _ = sys.exc_info() + if (r.buf.find(expected) >= 0): + log("Out exception includes expected one, pass:") + log(" Expected: %s" % expected) + log(" Got: %s" % r.buf) + else: + raise Exception("Failed:\n expected: '%s'\n got: '%s'" % + (expected, r.buf)) + + +if __name__ == "__main__": + opts = parser.parse_args(sys.argv[1:]) + # print('Input param :',opts) + + if opts.aot: + test_aot = True + # default x86_64 + test_target = opts.target + + if opts.rundir: + os.chdir(opts.rundir) + + if opts.log_file: + log_file = open(opts.log_file, "a") + if opts.debug_file: + debug_file = open(opts.debug_file, "a") + + if opts.interpreter.endswith(".py"): + SKIP_TESTS = PY_SKIP_TESTS + else: + SKIP_TESTS = C_SKIP_TESTS + + wast_tempfile = create_tmp_file(".wast") + wasm_tempfile = create_tmp_file(".wasm") + if test_aot: + aot_tempfile = create_tmp_file(".aot") + + ret_code = 0 + try: + log("\n################################################") + log("### Testing %s" % opts.test_file.name) + log("################################################") + forms = read_forms(opts.test_file.read()) + r = None + + for form in forms: + # log("\n### Current Case is " + form + "\n") + if ";;" == form[0:2]: + log(form) + elif skip_test(form, SKIP_TESTS): + log("Skipping test: %s" % form[0:60]) + elif re.match("^\(assert_trap\s+\(module", form): + test_assert_with_exception( + form, wast_tempfile, wasm_tempfile, aot_tempfile if test_aot else None, opts, r) + elif re.match("^\(assert_exhaustion\\b.*", form): + test_assert_exhaustion(r, opts, form) + elif re.match("^\(assert_unlinkable\\b.*", form): + test_assert_with_exception( + form, wast_tempfile, wasm_tempfile, aot_tempfile if test_aot else None, opts, r, False) + elif re.match("^\(assert_malformed\\b.*", form): + # remove comments in wast + form, n = re.subn(";;.*\n", "", form) + m = re.match( + "^\(assert_malformed\s*\(module binary\s*(\".*\").*\)\s*\"(.*)\"\s*\)$", form, re.DOTALL) + + if m: + # workaround: spec test changes error message to "malformed" while iwasm still use "invalid" + error_msg = m.group(2).replace("malformed", "invalid") + log("Testing(malformed)") + with open(wasm_tempfile, 'wb') as f: + s = m.group(1) + while s: + res = re.match( + "[^\"]*\"([^\"]*)\"(.*)", s, re.DOTALL) + if IS_PY_3: + context = res.group(1).replace("\\", "\\x").encode( + "latin1").decode("unicode-escape").encode("latin1") + f.write(context) + else: + f.write(res.group(1).replace( + "\\", "\\x").decode("string-escape")) + s = res.group(2) + + # compile wasm to aot + if test_aot: + r = compile_wasm_to_aot( + wasm_tempfile, aot_tempfile, True, opts, r) + try: + assert_prompt(r, ['Compile success'], + opts.start_timeout, True) + except: + _, exc, _ = sys.exc_info() + if (r.buf.find(error_msg) >= 0): + log("Out exception includes expected one, pass:") + log(" Expected: %s" % error_msg) + log(" Got: %s" % r.buf) + continue + # one case in binary.wast + elif (error_msg == "unexpected end of section or function" + and r.buf.find("unexpected end")): + continue + # one case in binary.wast + elif (error_msg == "invalid value type" + and r.buf.find("unexpected end")): + continue + # one case in binary.wast + elif (error_msg == "integer too large" + and r.buf.find("tables cannot be shared")): + continue + # one case in binary.wast + elif (error_msg == "zero byte expected" + and r.buf.find("unknown table")): + continue + # one case in binary.wast + elif (error_msg == "invalid section id" + and r.buf.find("unexpected end of section or function")): + continue + # one case in binary.wast + elif (error_msg == "illegal opcode" + and r.buf.find("unexpected end of section or function")): + continue + # one case in custom.wast + elif (error_msg == "length out of bounds" + and r.buf.find("unexpected end")): + continue + # several cases in binary-leb128.wast + elif (error_msg == "integer representation too long" + and r.buf.find("invalid section id")): + continue + else: + log("Run wamrc failed:\n expected: '%s'\n got: '%s'" % + (error_msg, r.buf)) + ret_code = 1 + sys.exit(1) + + r = run_wasm_with_repl( + wasm_tempfile, aot_tempfile if test_aot else None, opts, r) + + elif re.match("^\(assert_malformed\s*\(module quote", form): + log("ignoring assert_malformed module quote") + else: + log("unrecognized assert_malformed") + elif re.match("^\(assert_return[_a-z]*_nan\\b.*", form): + log("ignoring assert_return_.*_nan") + pass + elif re.match(".*\(invoke\s+\$\\b.*", form): + # invoke a particular named module's function + if form.startswith("(assert_return"): + test_assert_return(r, opts, form) + elif form.startswith("(assert_trap"): + test_assert_trap(r, opts, form) + elif re.match("^\(module\\b.*", form): + # if the module includes the particular name startswith $ + m = re.search("^\(module\s+\$.\S+", form) + if m: + # get module name + module_name = re.split('\$', m.group(0).strip())[1] + if module_name: + # create temporal files + temp_files = create_tmpfiles(module_name) + if not compile_wast_to_wasm(form, temp_files[0], temp_files[1], opts): + raise Exception("compile wast to wasm failed") + + if test_aot: + r = compile_wasm_to_aot( + temp_files[1], temp_files[2], True, opts, r) + try: + assert_prompt( + r, ['Compile success'], opts.start_timeout, False) + except: + _, exc, _ = sys.exc_info() + log("Run wamrc failed:\n got: '%s'" % r.buf) + ret_code = 1 + sys.exit(1) + temp_module_table[module_name] = temp_files[1] + r = run_wasm_with_repl( + temp_files[1], temp_files[2] if test_aot else None, opts, r) + else: + if not compile_wast_to_wasm(form, wast_tempfile, wasm_tempfile, opts): + raise Exception("compile wast to wasm failed") + + if test_aot: + r = compile_wasm_to_aot( + wasm_tempfile, aot_tempfile, True, opts, r) + try: + assert_prompt(r, ['Compile success'], + opts.start_timeout, False) + except: + _, exc, _ = sys.exc_info() + log("Run wamrc failed:\n got: '%s'" % r.buf) + ret_code = 1 + sys.exit(1) + + r = run_wasm_with_repl( + wasm_tempfile, aot_tempfile if test_aot else None, opts, r) + + # Wait for the initial prompt + try: + assert_prompt(r, ['webassembly> '], + opts.start_timeout, False) + except: + _, exc, _ = sys.exc_info() + raise Exception("Failed:\n expected: '%s'\n got: '%s'" % + (repr(exc), r.buf)) + + elif re.match("^\(assert_return\\b.*", form): + assert (r), "iwasm repl runtime should be not null" + test_assert_return(r, opts, form) + elif re.match("^\(assert_trap\\b.*", form): + test_assert_trap(r, opts, form) + elif re.match("^\(invoke\\b.*", form): + assert (r), "iwasm repl runtime should be not null" + do_invoke(r, opts, form) + elif re.match("^\(assert_invalid\\b.*", form): + test_assert_with_exception( + form, wast_tempfile, wasm_tempfile, aot_tempfile if test_aot else None, opts, r) + elif re.match("^\(register\\b.*", form): + # get module's new name from the register cmd + name_new = re.split('\"', re.search( + '\".*\"', form).group(0))[1] + if name_new: + new_module = os.path.join( + tempfile.gettempdir(), name_new + ".wasm") + shutil.copyfile(temp_module_table.get( + name_new, wasm_tempfile), new_module) + + # add new_module copied from the old into temp_file_repo[] + temp_file_repo.append(new_module) + + if test_aot: + new_module_aot = os.path.join( + tempfile.gettempdir(), name_new + ".aot") + r = compile_wasm_to_aot( + new_module, new_module_aot, True, opts, r) + try: + assert_prompt(r, ['Compile success'], + opts.start_timeout, True) + except: + raise Exception("compile wasm to aot failed") + # add aot module into temp_file_repo[] + temp_file_repo.append(new_module_aot) + else: + # there is no name defined in register cmd + raise Exception( + "can not find module name from the register") + else: + raise Exception("unrecognized form '%s...'" % form[0:40]) + except Exception as e: + traceback.print_exc() + print("THE FINAL EXCEPTION IS {}".format(e)) + ret_code = 101 + + shutil.copyfile(wasm_tempfile, os.path.join( + opts.log_dir, os.path.basename(wasm_tempfile))) + + if opts.aot or opts.xip: + shutil.copyfile(aot_tempfile, os.path.join( + opts.log_dir, os.path.basename(aot_tempfile))) + if "indirect-mode" in str(e): + compile_wasm_to_aot( + wasm_tempfile, aot_tempfile, None, opts, None, "object") + shutil.copyfile(aot_tempfile, os.path.join( + opts.log_dir, os.path.basename(aot_tempfile)+'.o')) + subprocess.check_call(["llvm-objdump", "-r", aot_tempfile]) + compile_wasm_to_aot(wasm_tempfile, aot_tempfile, + None, opts, None, "ir") + shutil.copyfile(aot_tempfile, os.path.join( + opts.log_dir, os.path.basename(aot_tempfile)+".ir")) + + else: + ret_code = 0 + finally: + if not opts.no_cleanup: + log("Removing tempfiles") + os.remove(wast_tempfile) + os.remove(wasm_tempfile) + if test_aot: + os.remove(aot_tempfile) + + # remove the files under /tempfiles/ and copy of .wasm files + if temp_file_repo: + for t in temp_file_repo: + if (len(str(t)) != 0 and os.path.exists(t)): + os.remove(t) + + log("### End testing %s" % opts.test_file.name) + else: + log("Leaving tempfiles: %s" % ([wast_tempfile, wasm_tempfile])) + + sys.exit(ret_code) diff --git a/tests/requirement-engineering/gc-aot/test_cases.json b/tests/requirement-engineering/gc-aot/test_cases.json new file mode 100644 index 00000000..95919819 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/test_cases.json @@ -0,0 +1,115 @@ +{ + "name": "gc-aot-test-suites", + "description": "Test suites for GC AOT feature", + "sub-requirements": [ + { + "req_id": 1, + "issue_id": "633", + "desciption": "Modify existing opcodes to conform to the semantics of the GC proposal when needed.", + "cases": [ + { + "name": "local_set", + "description": "Test opcodes: 'WASM_OP_GET_LOCAL', 'WASM_OP_SET_LOCAL'" + }, + { + "name": "local_tee", + "description": "Test opcodes: 'WASM_OP_GET_LOCAL', 'WASM_OP_TEE_LOCAL'" + }, + { + "name": "table_init", + "description": "Test opcodes: 'WASM_OP_TABLE_INIT'" + }, + { + "name": "table_grow", + "description": "Test opcodes: 'WASM_OP_TABLE_GROW'" + }, + { + "name": "table_fill", + "description": "Test opcodes: 'WASM_OP_TABLE_FILL'" + }, + { + "name": "call_ref", + "description": "Test opcodes: 'WASM_OP_CALL_REF'" + }, + { + "name": "return_call_ref", + "description": "Test opcodes: 'WASM_OP_RETURN_CALL_REF'" + }, + { + "name": "table_get", + "description": "Test opcodes: 'WASM_OP_TABLE_GET'" + }, + { + "name": "table_set", + "description": "Test opcodes: 'WASM_OP_TABLE_SET'" + }, + { + "name": "select", + "description": "Test opcodes: 'WASM_OP_SELECT_T'" + } + ] + }, + { + "req_id": 2, + "issue_id": "634", + "desciption": "Supporting new GC opcodes(semantics of GC MVP proposal spec).", + "cases": [ + { + "name": "ref_test", + "description": "Test opcodes: 'WASM_OP_TABLE_GET', 'WASM_OP_TABLE_SET', 'WASM_OP_REF_NULL', 'WASM_OP_REF_IS_NULL', 'WASM_OP_REF_TEST', 'WASM_OP_REF_TEST_NULLABLE'" + }, + { + "name": "ref_eq", + "description": "Test opcodes: 'WASM_OP_REF_EQ', 'WASM_OP_GET_LOCAL'" + }, + { + "name": "ref_cast", + "description": "Test opcodes: 'WASM_OP_REF_CAST', 'WASM_OP_REF_CAST_NULLABLE', 'WASM_OP_REF_AS_NON_NULL'" + }, + { + "name": "type_subtyping", + "description": "Test opcodes: 'WASM_OP_CALL_INDIRECT', 'WASM_OP_REF_FUNC'" + }, + { + "name": "array", + "description": "Test opcodes: 'WASM_OP_ARRAY_NEW', 'WASM_OP_ARRAY_NEW_DEFAULT', 'WASM_OP_ARRAY_NEW_FIXED', 'WASM_OP_ARRAY_NEW_DATA', 'WASM_OP_ARRAY_GET', 'WASM_OP_ARRAY_GET_S', 'WASM_OP_ARRAY_GET_U', 'WASM_OP_ARRAY_SET', 'WASM_OP_ARRAY_LEN'" + }, + { + "name": "array_fill", + "description": "Test opcodes: 'WASM_OP_ARRAY_FILL'" + }, + { + "name": "struct", + "description": "Test opcodes: 'WASM_OP_STRUCT_NEW', 'WASM_OP_STRUCT_NEW_DEFAULT', 'WASM_OP_STRUCT_GET', 'WASM_OP_STRUCT_GET_S', 'WASM_OP_STRUCT_GET_U', 'WASM_OP_STRUCT_SET'" + }, + { + "name": "i31", + "description": "Test opcodes: 'WASM_OP_I31_NEW', 'WASM_OP_I31_GET_S', 'WASM_OP_I31_GET_U'" + }, + { + "name": "br_on_cast", + "description": "Test opcodes: 'WASM_OP_BR_ON_NULL', 'WASM_OP_BR_ON_CAST'" + }, + { + "name": "br_on_cast_fail", + "description": "Test opcodes: 'WASM_OP_BR_ON_NON_NULL', 'WASM_OP_BR_ON_CAST_FAIL'" + }, + { + "name": "extern", + "description": "Test opcodes: 'WASM_OP_ANY_CONVERT_EXTERN', 'WASM_OP_EXTERN_CONVERT_ANY'" + } + ] + }, + { + "req_id": 3, + "issue_id": "635", + "desciption": "Supporting new GC opcode(semantics of Binaryen GC spec).", + "cases": [ + { + "name": "array_copy", + "description": "Test the opcodes: 'WASM_OP_ARRAY_COPY', 'WASM_OP_SET_LOCAL'" + } + ] + } + ] +} diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/array.wast b/tests/requirement-engineering/gc-aot/wasm-apps/array.wast new file mode 100644 index 00000000..b4a2dc0a --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/array.wast @@ -0,0 +1,308 @@ +;; Type syntax + +(module + (type (array i8)) + (type (array i16)) + (type (array i32)) + (type (array i64)) + (type (array f32)) + (type (array f64)) + (type (array anyref)) + (type (array (ref struct))) + (type (array (ref 0))) + (type (array (ref null 1))) + (type (array (mut i8))) + (type (array (mut i16))) + (type (array (mut i32))) + (type (array (mut i64))) + (type (array (mut i32))) + (type (array (mut i64))) + (type (array (mut anyref))) + (type (array (mut (ref struct)))) + (type (array (mut (ref 0)))) + (type (array (mut (ref null i31)))) +) + + +(assert_invalid + (module + (type (array (mut (ref null 10)))) + ) + "unknown type" +) + + +;; Binding structure + +(module + (rec + (type $s0 (array (ref $s1))) + (type $s1 (array (ref $s0))) + ) + + (func (param (ref $forward))) + + (type $forward (array i32)) +) + +(assert_invalid + (module (type (array (ref 1)))) + "unknown type" +) +(assert_invalid + (module (type (array (mut (ref 1))))) + "unknown type" +) + + +;; Basic instructions + +(module + (type $vec (array f32)) + (type $mvec (array (mut f32))) + + (global (ref $vec) (array.new $vec (f32.const 1) (i32.const 3))) + (global (ref $vec) (array.new_default $vec (i32.const 3))) + + (func $new (export "new") (result (ref $vec)) + (array.new_default $vec (i32.const 3)) + ) + + (func $get (param $i i32) (param $v (ref $vec)) (result f32) + (array.get $vec (local.get $v) (local.get $i)) + ) + (func (export "get") (param $i i32) (result f32) + (call $get (local.get $i) (call $new)) + ) + + (func $set_get (param $i i32) (param $v (ref $mvec)) (param $y f32) (result f32) + (array.set $mvec (local.get $v) (local.get $i) (local.get $y)) + (array.get $mvec (local.get $v) (local.get $i)) + ) + (func (export "set_get") (param $i i32) (param $y f32) (result f32) + (call $set_get (local.get $i) + (array.new_default $mvec (i32.const 3)) + (local.get $y) + ) + ) + + (func $len (param $v (ref array)) (result i32) + (array.len (local.get $v)) + ) + (func (export "len") (result i32) + (call $len (call $new)) + ) +) + +(assert_return (invoke "new") (ref.array)) +;; (assert_return (invoke "new") (ref.eq)) +(assert_return (invoke "get" (i32.const 0)) (f32.const 0)) +(assert_return (invoke "set_get" (i32.const 1) (f32.const 7)) (f32.const 7)) +(assert_return (invoke "len") (i32.const 3)) + +(assert_trap (invoke "get" (i32.const 10)) "out of bounds array access") +(assert_trap (invoke "set_get" (i32.const 10) (f32.const 7)) "out of bounds array access") + +(module + (type $vec (array f32)) + (type $mvec (array (mut f32))) + + (global (ref $vec) (array.new_fixed $vec 2 (f32.const 1) (f32.const 2))) + + (func $new (export "new") (result (ref $vec)) + (array.new_fixed $vec 2 (f32.const 1) (f32.const 2)) + ) + + (func $get (param $i i32) (param $v (ref $vec)) (result f32) + (array.get $vec (local.get $v) (local.get $i)) + ) + (func (export "get") (param $i i32) (result f32) + (call $get (local.get $i) (call $new)) + ) + + (func $set_get (param $i i32) (param $v (ref $mvec)) (param $y f32) (result f32) + (array.set $mvec (local.get $v) (local.get $i) (local.get $y)) + (array.get $mvec (local.get $v) (local.get $i)) + ) + (func (export "set_get") (param $i i32) (param $y f32) (result f32) + (call $set_get (local.get $i) + (array.new_fixed $mvec 3 (f32.const 1) (f32.const 2) (f32.const 3)) + (local.get $y) + ) + ) + + (func $len (param $v (ref array)) (result i32) + (array.len (local.get $v)) + ) + (func (export "len") (result i32) + (call $len (call $new)) + ) +) + +(assert_return (invoke "new") (ref.array)) +;; (assert_return (invoke "new") (ref.eq)) +(assert_return (invoke "get" (i32.const 0)) (f32.const 1)) +(assert_return (invoke "set_get" (i32.const 1) (f32.const 7)) (f32.const 7)) +(assert_return (invoke "len") (i32.const 2)) + +(assert_trap (invoke "get" (i32.const 10)) "out of bounds array access") +(assert_trap (invoke "set_get" (i32.const 10) (f32.const 7)) "out of bounds array access") + +(module + (type $vec (array i8)) + (type $mvec (array (mut i8))) + + (data $d "\00\01\02\03\04") + + (func $new (export "new") (result (ref $vec)) + (array.new_data $vec $d (i32.const 1) (i32.const 3)) + ) + + (func $get (param $i i32) (param $v (ref $vec)) (result i32) + (array.get_u $vec (local.get $v) (local.get $i)) + ) + (func (export "get") (param $i i32) (result i32) + (call $get (local.get $i) (call $new)) + ) + + (func $set_get (param $i i32) (param $v (ref $mvec)) (param $y i32) (result i32) + (array.set $mvec (local.get $v) (local.get $i) (local.get $y)) + (array.get_u $mvec (local.get $v) (local.get $i)) + ) + (func (export "set_get") (param $i i32) (param $y i32) (result i32) + (call $set_get (local.get $i) + (array.new_data $mvec $d (i32.const 1) (i32.const 3)) + (local.get $y) + ) + ) + + (func $len (param $v (ref array)) (result i32) + (array.len (local.get $v)) + ) + (func (export "len") (result i32) + (call $len (call $new)) + ) +) + +(assert_return (invoke "new") (ref.array)) +;; (assert_return (invoke "new") (ref.eq)) +(assert_return (invoke "get" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "set_get" (i32.const 1) (i32.const 7)) (i32.const 7)) +(assert_return (invoke "len") (i32.const 3)) + +(assert_trap (invoke "get" (i32.const 10)) "out of bounds array access") +(assert_trap (invoke "set_get" (i32.const 10) (i32.const 7)) "out of bounds array access") + +(; array.new_elem not supported +(module + (type $bvec (array i8)) + (type $vec (array (ref $bvec))) + (type $mvec (array (mut (ref $bvec)))) + (type $nvec (array (ref null $bvec))) + (type $avec (array (mut anyref))) + + (elem $e (ref $bvec) + (array.new $bvec (i32.const 7) (i32.const 3)) + (array.new_fixed $bvec 2 (i32.const 1) (i32.const 2)) + ) + + (func $new (export "new") (result (ref $vec)) + (array.new_elem $vec $e (i32.const 0) (i32.const 2)) + ) + + (func $sub1 (result (ref $nvec)) + (array.new_elem $nvec $e (i32.const 0) (i32.const 2)) + ) + (func $sub2 (result (ref $avec)) + (array.new_elem $avec $e (i32.const 0) (i32.const 2)) + ) + + (func $get (param $i i32) (param $j i32) (param $v (ref $vec)) (result i32) + (array.get_u $bvec (array.get $vec (local.get $v) (local.get $i)) (local.get $j)) + ) + (func (export "get") (param $i i32) (param $j i32) (result i32) + (call $get (local.get $i) (local.get $j) (call $new)) + ) + + (func $set_get (param $i i32) (param $j i32) (param $v (ref $mvec)) (param $y i32) (result i32) + (array.set $mvec (local.get $v) (local.get $i) (array.get $mvec (local.get $v) (local.get $y))) + (array.get_u $bvec (array.get $mvec (local.get $v) (local.get $i)) (local.get $j)) + ) + (func (export "set_get") (param $i i32) (param $j i32) (param $y i32) (result i32) + (call $set_get (local.get $i) (local.get $j) + (array.new_elem $mvec $e (i32.const 0) (i32.const 2)) + (local.get $y) + ) + ) + + (func $len (param $v (ref array)) (result i32) + (array.len (local.get $v)) + ) + (func (export "len") (result i32) + (call $len (call $new)) + ) +) + +(assert_return (invoke "new") (ref.array)) +(assert_return (invoke "new") (ref.eq)) +(assert_return (invoke "get" (i32.const 0) (i32.const 0)) (i32.const 7)) +(assert_return (invoke "get" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "set_get" (i32.const 0) (i32.const 1) (i32.const 1)) (i32.const 2)) +(assert_return (invoke "len") (i32.const 2)) + +(assert_trap (invoke "get" (i32.const 10) (i32.const 0)) "out of bounds array access") +(assert_trap (invoke "set_get" (i32.const 10) (i32.const 0) (i32.const 0)) "out of bounds array access") +;) + +(assert_invalid + (module + (type $a (array i64)) + (func (export "array.set-immutable") (param $a (ref $a)) + (array.set $a (local.get $a) (i32.const 0) (i64.const 1)) + ) + ) + "array is immutable" +) + +(assert_invalid + (module + (type $bvec (array i8)) + + (data $d "\00\01\02\03\04") + + (global (ref $bvec) + (array.new_data $bvec $d (i32.const 1) (i32.const 3)) + ) + ) + "constant expression required" +) + +(assert_invalid + (module + (type $bvec (array i8)) + (type $vvec (array (ref $bvec))) + + (elem $e (ref $bvec) (ref.null $bvec)) + + (global (ref $vvec) + (array.new_elem $vvec $e (i32.const 0) (i32.const 1)) + ) + ) + "constant expression required" +) + + +;; Null dereference + +(module + (type $t (array (mut i32))) + (func (export "array.get-null") + (local (ref null $t)) (drop (array.get $t (local.get 0) (i32.const 0))) + ) + (func (export "array.set-null") + (local (ref null $t)) (array.set $t (local.get 0) (i32.const 0) (i32.const 0)) + ) +) + +(assert_trap (invoke "array.get-null") "null array") +(assert_trap (invoke "array.set-null") "null array") diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/array_copy.wast b/tests/requirement-engineering/gc-aot/wasm-apps/array_copy.wast new file mode 100644 index 00000000..d1caf126 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/array_copy.wast @@ -0,0 +1,139 @@ +;; Bulk instructions + +;; invalid uses + +(assert_invalid + (module + (type $a (array i8)) + (type $b (array (mut i8))) + + (func (export "array.copy-immutable") (param $1 (ref $a)) (param $2 (ref $b)) + (array.copy $a $b (local.get $1) (i32.const 0) (local.get $2) (i32.const 0) (i32.const 0)) + ) + ) + "array is immutable" +) + +(assert_invalid + (module + (type $a (array (mut i8))) + (type $b (array i16)) + + (func (export "array.copy-packed-invalid") (param $1 (ref $a)) (param $2 (ref $b)) + (array.copy $a $b (local.get $1) (i32.const 0) (local.get $2) (i32.const 0) (i32.const 0)) + ) + ) + "array types do not match" +) + +(assert_invalid + (module + (type $a (array (mut i8))) + (type $b (array (mut (ref $a)))) + + (func (export "array.copy-ref-invalid-1") (param $1 (ref $a)) (param $2 (ref $b)) + (array.copy $a $b (local.get $1) (i32.const 0) (local.get $2) (i32.const 0) (i32.const 0)) + ) + ) + "array types do not match" +) + +(assert_invalid + (module + (type $a (array (mut i8))) + (type $b (array (mut (ref $a)))) + (type $c (array (mut (ref $b)))) + + (func (export "array.copy-ref-invalid-1") (param $1 (ref $b)) (param $2 (ref $c)) + (array.copy $b $c (local.get $1) (i32.const 0) (local.get $2) (i32.const 0) (i32.const 0)) + ) + ) + "array types do not match" +) + +(module + (type $arr8 (array i8)) + (type $arr8_mut (array (mut i8))) + + (global $g_arr8 (ref $arr8) (array.new $arr8 (i32.const 10) (i32.const 12))) + (global $g_arr8_mut (mut (ref $arr8_mut)) (array.new_default $arr8_mut (i32.const 12))) + + (data $d1 "abcdefghijkl") + + (func (export "array_get_nth") (param $1 i32) (result i32) + (array.get_u $arr8_mut (global.get $g_arr8_mut) (local.get $1)) + ) + + (func (export "array_copy-null-left") + (array.copy $arr8_mut $arr8 (ref.null $arr8_mut) (i32.const 0) (global.get $g_arr8) (i32.const 0) (i32.const 0)) + ) + + (func (export "array_copy-null-right") + (array.copy $arr8_mut $arr8 (global.get $g_arr8_mut) (i32.const 0) (ref.null $arr8) (i32.const 0) (i32.const 0)) + ) + + (func (export "array_copy") (param $1 i32) (param $2 i32) (param $3 i32) + (array.copy $arr8_mut $arr8 (global.get $g_arr8_mut) (local.get $1) (global.get $g_arr8) (local.get $2) (local.get $3)) + ) + + (func (export "array_copy_overlap_test-1") + (local $1 (ref $arr8_mut)) + (array.new_data $arr8_mut $d1 (i32.const 0) (i32.const 12)) + (local.set $1) + (array.copy $arr8_mut $arr8_mut (local.get $1) (i32.const 1) (local.get $1) (i32.const 0) (i32.const 11)) + (global.set $g_arr8_mut (local.get $1)) + ) + + (func (export "array_copy_overlap_test-2") + (local $1 (ref $arr8_mut)) + (array.new_data $arr8_mut $d1 (i32.const 0) (i32.const 12)) + (local.set $1) + (array.copy $arr8_mut $arr8_mut (local.get $1) (i32.const 0) (local.get $1) (i32.const 1) (i32.const 11)) + (global.set $g_arr8_mut (local.get $1)) + ) +) + +;; null array argument traps +(assert_trap (invoke "array_copy-null-left") "null array reference") +(assert_trap (invoke "array_copy-null-right") "null array reference") + +;; OOB initial index traps +(assert_trap (invoke "array_copy" (i32.const 13) (i32.const 0) (i32.const 0)) "out of bounds array access") +(assert_trap (invoke "array_copy" (i32.const 0) (i32.const 13) (i32.const 0)) "out of bounds array access") + +;; OOB length traps +(assert_trap (invoke "array_copy" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access") +(assert_trap (invoke "array_copy" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access") + +;; start index = array size, len = 0 doesn't trap +(assert_return (invoke "array_copy" (i32.const 12) (i32.const 0) (i32.const 0))) +(assert_return (invoke "array_copy" (i32.const 0) (i32.const 12) (i32.const 0))) + +;; check arrays were not modified +(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 0)) +(assert_trap (invoke "array_get_nth" (i32.const 12)) "out of bounds array access") + +;; normal case +(assert_return (invoke "array_copy" (i32.const 0) (i32.const 0) (i32.const 2))) +(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 10)) +(assert_return (invoke "array_get_nth" (i32.const 1)) (i32.const 10)) +(assert_return (invoke "array_get_nth" (i32.const 2)) (i32.const 0)) + +;; test that overlapping array.copy works as if intermediate copy taken +(assert_return (invoke "array_copy_overlap_test-1")) +(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 97)) +(assert_return (invoke "array_get_nth" (i32.const 1)) (i32.const 97)) +(assert_return (invoke "array_get_nth" (i32.const 2)) (i32.const 98)) +(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 101)) +(assert_return (invoke "array_get_nth" (i32.const 10)) (i32.const 106)) +(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 107)) + +(assert_return (invoke "array_copy_overlap_test-2")) +(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 98)) +(assert_return (invoke "array_get_nth" (i32.const 1)) (i32.const 99)) +(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 103)) +(assert_return (invoke "array_get_nth" (i32.const 9)) (i32.const 107)) +(assert_return (invoke "array_get_nth" (i32.const 10)) (i32.const 108)) +(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 108)) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/array_fill.wast b/tests/requirement-engineering/gc-aot/wasm-apps/array_fill.wast new file mode 100644 index 00000000..0379ad53 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/array_fill.wast @@ -0,0 +1,81 @@ +;; Bulk instructions + +;; invalid uses + +(assert_invalid + (module + (type $a (array i8)) + + (func (export "array.fill-immutable") (param $1 (ref $a)) (param $2 i32) + (array.fill $a (local.get $1) (i32.const 0) (local.get $2) (i32.const 0)) + ) + ) + "array is immutable" +) + +(assert_invalid + (module + (type $a (array (mut i8))) + + (func (export "array.fill-invalid-1") (param $1 (ref $a)) (param $2 funcref) + (array.fill $a (local.get $1) (i32.const 0) (local.get $2) (i32.const 0)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $b (array (mut funcref))) + + (func (export "array.fill-invalid-1") (param $1 (ref $b)) (param $2 i32) + (array.fill $b (local.get $1) (i32.const 0) (local.get $2) (i32.const 0)) + ) + ) + "type mismatch" +) + +(module + (type $arr8 (array i8)) + (type $arr8_mut (array (mut i8))) + + (global $g_arr8 (ref $arr8) (array.new $arr8 (i32.const 10) (i32.const 12))) + (global $g_arr8_mut (mut (ref $arr8_mut)) (array.new_default $arr8_mut (i32.const 12))) + + (func (export "array_get_nth") (param $1 i32) (result i32) + (array.get_u $arr8_mut (global.get $g_arr8_mut) (local.get $1)) + ) + + (func (export "array_fill-null") + (array.fill $arr8_mut (ref.null $arr8_mut) (i32.const 0) (i32.const 0) (i32.const 0)) + ) + + (func (export "array_fill") (param $1 i32) (param $2 i32) (param $3 i32) + (array.fill $arr8_mut (global.get $g_arr8_mut) (local.get $1) (local.get $2) (local.get $3)) + ) +) + +;; null array argument traps +(assert_trap (invoke "array_fill-null") "null array reference") + +;; OOB initial index traps +(assert_trap (invoke "array_fill" (i32.const 13) (i32.const 0) (i32.const 0)) "out of bounds array access") + +;; OOB length traps +(assert_trap (invoke "array_fill" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access") + +;; start index = array size, len = 0 doesn't trap +(assert_return (invoke "array_fill" (i32.const 12) (i32.const 0) (i32.const 0))) + +;; check arrays were not modified +(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 0)) +(assert_trap (invoke "array_get_nth" (i32.const 12)) "out of bounds array access") + +;; normal case +(assert_return (invoke "array_fill" (i32.const 2) (i32.const 11) (i32.const 2))) +(assert_return (invoke "array_get_nth" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "array_get_nth" (i32.const 2)) (i32.const 11)) +(assert_return (invoke "array_get_nth" (i32.const 3)) (i32.const 11)) +(assert_return (invoke "array_get_nth" (i32.const 4)) (i32.const 0)) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/br_on_cast.wast b/tests/requirement-engineering/gc-aot/wasm-apps/br_on_cast.wast new file mode 100644 index 00000000..37aec62d --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/br_on_cast.wast @@ -0,0 +1,267 @@ +;; Abstract Types + +(module + (type $ft (func (result i32))) + (type $st (struct (field i16))) + (type $at (array i8)) + + (table 10 anyref) + + (elem declare func $f) + (func $f (result i32) (i32.const 9)) + + (func (export "init") (param $x externref) + (table.set (i32.const 0) (ref.null any)) + (table.set (i32.const 1) (ref.i31 (i32.const 7))) + (table.set (i32.const 2) (struct.new $st (i32.const 6))) + (table.set (i32.const 3) (array.new $at (i32.const 5) (i32.const 3))) + (table.set (i32.const 4) (any.convert_extern (local.get $x))) + ) + + (func (export "br_on_null") (param $i i32) (result i32) + (block $l + (br_on_null $l (table.get (local.get $i))) + (return (i32.const -1)) + ) + (i32.const 0) + ) + (func (export "br_on_i31") (param $i i32) (result i32) + (block $l (result (ref i31)) + (br_on_cast $l anyref (ref i31) (table.get (local.get $i))) + (return (i32.const -1)) + ) + (i31.get_u) + ) + (func (export "br_on_struct") (param $i i32) (result i32) + (block $l (result (ref struct)) + (br_on_cast $l anyref (ref struct) (table.get (local.get $i))) + (return (i32.const -1)) + ) + (block $l2 (param structref) (result (ref $st)) + (block $l3 (param structref) (result (ref $at)) + (br_on_cast $l2 structref (ref $st)) + (br_on_cast $l3 anyref (ref $at)) + (return (i32.const -2)) + ) + (return (array.get_u $at (i32.const 0))) + ) + (struct.get_s $st 0) + ) + (func (export "br_on_array") (param $i i32) (result i32) + (block $l (result (ref array)) + (br_on_cast $l anyref (ref array) (table.get (local.get $i))) + (return (i32.const -1)) + ) + (array.len) + ) + + (func (export "null-diff") (param $i i32) (result i32) + (block $l (result (ref null struct)) + (block (result (ref any)) + (br_on_cast $l (ref null any) (ref null struct) (table.get (local.get $i))) + ) + (return (i32.const 0)) + ) + (return (i32.const 1)) + ) +) + +(invoke "init" (ref.extern 0)) + +(assert_return (invoke "br_on_null" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "br_on_null" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "br_on_null" (i32.const 2)) (i32.const -1)) +(assert_return (invoke "br_on_null" (i32.const 3)) (i32.const -1)) +(assert_return (invoke "br_on_null" (i32.const 4)) (i32.const -1)) + +(assert_return (invoke "br_on_i31" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "br_on_i31" (i32.const 1)) (i32.const 7)) +(assert_return (invoke "br_on_i31" (i32.const 2)) (i32.const -1)) +(assert_return (invoke "br_on_i31" (i32.const 3)) (i32.const -1)) +(assert_return (invoke "br_on_i31" (i32.const 4)) (i32.const -1)) + +(assert_return (invoke "br_on_struct" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "br_on_struct" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "br_on_struct" (i32.const 2)) (i32.const 6)) +(assert_return (invoke "br_on_struct" (i32.const 3)) (i32.const -1)) +(assert_return (invoke "br_on_struct" (i32.const 4)) (i32.const -1)) + +(assert_return (invoke "br_on_array" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "br_on_array" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "br_on_array" (i32.const 2)) (i32.const -1)) +(assert_return (invoke "br_on_array" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "br_on_array" (i32.const 4)) (i32.const -1)) + +(assert_return (invoke "null-diff" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "null-diff" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "null-diff" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "null-diff" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "null-diff" (i32.const 4)) (i32.const 0)) + + +;; Concrete Types + +(module + (type $t0 (sub (struct))) + (type $t1 (sub $t0 (struct (field i32)))) + (type $t1' (sub $t0 (struct (field i32)))) + (type $t2 (sub $t1 (struct (field i32 i32)))) + (type $t2' (sub $t1' (struct (field i32 i32)))) + (type $t3 (sub $t0 (struct (field i32 i32)))) + (type $t0' (sub $t0 (struct))) + (type $t4 (sub $t0' (struct (field i32 i32)))) + + (table 20 structref) + + (func $init + (table.set (i32.const 0) (struct.new_default $t0)) + (table.set (i32.const 10) (struct.new_default $t0')) + (table.set (i32.const 1) (struct.new_default $t1)) + (table.set (i32.const 11) (struct.new_default $t1')) + (table.set (i32.const 2) (struct.new_default $t2)) + (table.set (i32.const 12) (struct.new_default $t2')) + (table.set (i32.const 3) (struct.new_default $t3)) + (table.set (i32.const 4) (struct.new_default $t4)) + ) + + (func (export "test-sub") + (call $init) + (block $l (result structref) + ;; must succeed + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (ref.null struct)))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 0))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 1))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 2))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 3))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 4))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (ref.null struct)))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (table.get (i32.const 1))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (table.get (i32.const 2))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t2) (ref.null struct)))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t2) (table.get (i32.const 2))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t3) (ref.null struct)))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t3) (table.get (i32.const 3))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t4) (ref.null struct)))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t4) (table.get (i32.const 4))))) + + ;; must not succeed + (br_on_cast $l anyref (ref $t1) (table.get (i32.const 0))) + (br_on_cast $l anyref (ref $t1) (table.get (i32.const 3))) + (br_on_cast $l anyref (ref $t1) (table.get (i32.const 4))) + + (br_on_cast $l anyref (ref $t2) (table.get (i32.const 0))) + (br_on_cast $l anyref (ref $t2) (table.get (i32.const 1))) + (br_on_cast $l anyref (ref $t2) (table.get (i32.const 3))) + (br_on_cast $l anyref (ref $t2) (table.get (i32.const 4))) + + (br_on_cast $l anyref (ref $t3) (table.get (i32.const 0))) + (br_on_cast $l anyref (ref $t3) (table.get (i32.const 1))) + (br_on_cast $l anyref (ref $t3) (table.get (i32.const 2))) + (br_on_cast $l anyref (ref $t3) (table.get (i32.const 4))) + + (br_on_cast $l anyref (ref $t4) (table.get (i32.const 0))) + (br_on_cast $l anyref (ref $t4) (table.get (i32.const 1))) + (br_on_cast $l anyref (ref $t4) (table.get (i32.const 2))) + (br_on_cast $l anyref (ref $t4) (table.get (i32.const 3))) + + (return) + ) + (unreachable) + ) + + (func (export "test-canon") + (call $init) + (block $l + (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 0))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 1))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 2))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 3))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 4))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 10))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 11))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 12))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t1') (table.get (i32.const 1))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t1') (table.get (i32.const 2))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (table.get (i32.const 11))))) + (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (table.get (i32.const 12))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t2') (table.get (i32.const 2))))) + + (drop (block (result structref) (br_on_cast 0 structref (ref $t2) (table.get (i32.const 12))))) + + (return) + ) + (unreachable) + ) +) + +(invoke "test-sub") +(invoke "test-canon") + + +;; Cases of nullability + +(module + (type $t (struct)) + + (func (param (ref any)) (result (ref $t)) + (block (result (ref any)) (br_on_cast 1 (ref any) (ref $t) (local.get 0))) (unreachable) + ) + (func (param (ref null any)) (result (ref $t)) + (block (result (ref null any)) (br_on_cast 1 (ref null any) (ref $t) (local.get 0))) (unreachable) + ) + (func (param (ref null any)) (result (ref null $t)) + (block (result (ref null any)) (br_on_cast 1 (ref null any) (ref null $t) (local.get 0))) (unreachable) + ) +) + +(assert_invalid + (module + (type $t (struct)) + (func (param (ref any)) (result (ref $t)) + (block (result (ref any)) (br_on_cast 1 (ref null any) (ref null $t) (local.get 0))) (unreachable) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type $t (struct)) + (func (param (ref any)) (result (ref null $t)) + (block (result (ref any)) (br_on_cast 1 (ref any) (ref null $t) (local.get 0))) (unreachable) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type $t (struct)) + (func (param (ref null any)) (result (ref $t)) + (block (result (ref any)) (br_on_cast 1 (ref null any) (ref $t) (local.get 0))) (unreachable) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (result anyref) + (br_on_cast 0 eqref anyref (unreachable)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (result anyref) + (br_on_cast 0 structref arrayref (unreachable)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/br_on_cast_fail.wast b/tests/requirement-engineering/gc-aot/wasm-apps/br_on_cast_fail.wast new file mode 100644 index 00000000..f5559a61 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/br_on_cast_fail.wast @@ -0,0 +1,282 @@ +;; Abstract Types + +(module + (type $ft (func (result i32))) + (type $st (struct (field i16))) + (type $at (array i8)) + + (table 10 anyref) + + (elem declare func $f) + (func $f (result i32) (i32.const 9)) + + (func (export "init") (param $x externref) + (table.set (i32.const 0) (ref.null any)) + (table.set (i32.const 1) (ref.i31 (i32.const 7))) + (table.set (i32.const 2) (struct.new $st (i32.const 6))) + (table.set (i32.const 3) (array.new $at (i32.const 5) (i32.const 3))) + (table.set (i32.const 4) (any.convert_extern (local.get $x))) + ) + + (func (export "br_on_non_null") (param $i i32) (result i32) + (block $l (result (ref any)) + (br_on_non_null $l (table.get (local.get $i))) + (return (i32.const 0)) + ) + (return (i32.const -1)) + ) + (func (export "br_on_non_i31") (param $i i32) (result i32) + (block $l (result anyref) + (br_on_cast_fail $l anyref (ref i31) (table.get (local.get $i))) + (return (i31.get_u)) + ) + (return (i32.const -1)) + ) + (func (export "br_on_non_struct") (param $i i32) (result i32) + (block $l (result anyref) + (br_on_cast_fail $l anyref (ref struct) (table.get (local.get $i))) + (block $l2 (param structref) (result (ref $st)) + (block $l3 (param structref) (result (ref $at)) + (br_on_cast $l2 structref (ref $st)) + (br_on_cast $l3 anyref (ref $at)) + (return (i32.const -2)) + ) + (return (array.get_u $at (i32.const 0))) + ) + (return (struct.get_s $st 0)) + ) + (return (i32.const -1)) + ) + (func (export "br_on_non_array") (param $i i32) (result i32) + (block $l (result anyref) + (br_on_cast_fail $l anyref (ref array) (table.get (local.get $i))) + (return (array.len)) + ) + (return (i32.const -1)) + ) + + (func (export "null-diff") (param $i i32) (result i32) + (block $l (result (ref any)) + (block (result (ref null struct)) + (br_on_cast_fail $l (ref null any) (ref null struct) (table.get (local.get $i))) + ) + (return (i32.const 1)) + ) + (return (i32.const 0)) + ) +) + +(invoke "init" (ref.extern 0)) + +(assert_return (invoke "br_on_non_null" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "br_on_non_null" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "br_on_non_null" (i32.const 2)) (i32.const -1)) +(assert_return (invoke "br_on_non_null" (i32.const 3)) (i32.const -1)) +(assert_return (invoke "br_on_non_null" (i32.const 4)) (i32.const -1)) + +(assert_return (invoke "br_on_non_i31" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "br_on_non_i31" (i32.const 1)) (i32.const 7)) +(assert_return (invoke "br_on_non_i31" (i32.const 2)) (i32.const -1)) +(assert_return (invoke "br_on_non_i31" (i32.const 3)) (i32.const -1)) +(assert_return (invoke "br_on_non_i31" (i32.const 4)) (i32.const -1)) + +(assert_return (invoke "br_on_non_struct" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "br_on_non_struct" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "br_on_non_struct" (i32.const 2)) (i32.const 6)) +(assert_return (invoke "br_on_non_struct" (i32.const 3)) (i32.const -1)) +(assert_return (invoke "br_on_non_struct" (i32.const 4)) (i32.const -1)) + +(assert_return (invoke "br_on_non_array" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "br_on_non_array" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "br_on_non_array" (i32.const 2)) (i32.const -1)) +(assert_return (invoke "br_on_non_array" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "br_on_non_array" (i32.const 4)) (i32.const -1)) + +(assert_return (invoke "null-diff" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "null-diff" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "null-diff" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "null-diff" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "null-diff" (i32.const 4)) (i32.const 0)) + + +;; Concrete Types + +(module + (type $t0 (sub (struct))) + (type $t1 (sub $t0 (struct (field i32)))) + (type $t1' (sub $t0 (struct (field i32)))) + (type $t2 (sub $t1 (struct (field i32 i32)))) + (type $t2' (sub $t1' (struct (field i32 i32)))) + (type $t3 (sub $t0 (struct (field i32 i32)))) + (type $t0' (sub $t0 (struct))) + (type $t4 (sub $t0' (struct (field i32 i32)))) + + (table 20 structref) + + (func $init + (table.set (i32.const 0) (struct.new_default $t0)) + (table.set (i32.const 10) (struct.new_default $t0)) + (table.set (i32.const 1) (struct.new_default $t1)) + (table.set (i32.const 11) (struct.new_default $t1')) + (table.set (i32.const 2) (struct.new_default $t2)) + (table.set (i32.const 12) (struct.new_default $t2')) + (table.set (i32.const 3) (struct.new_default $t3 )) + (table.set (i32.const 4) (struct.new_default $t4)) + ) + + (func (export "test-sub") + (call $init) + (block $l (result structref) + ;; must not succeed + (br_on_cast_fail $l structref (ref null $t0) (ref.null struct)) + (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 0))) + (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 1))) + (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 2))) + (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 3))) + (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 4))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 0))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 1))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 2))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 3))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 4))) + + (br_on_cast_fail $l structref (ref null $t1) (ref.null struct)) + (br_on_cast_fail $l structref (ref null $t1) (table.get (i32.const 1))) + (br_on_cast_fail $l structref (ref null $t1) (table.get (i32.const 2))) + (br_on_cast_fail $l structref (ref $t1) (table.get (i32.const 1))) + (br_on_cast_fail $l structref (ref $t1) (table.get (i32.const 2))) + + (br_on_cast_fail $l structref (ref null $t2) (ref.null struct)) + (br_on_cast_fail $l structref (ref null $t2) (table.get (i32.const 2))) + (br_on_cast_fail $l structref (ref $t2) (table.get (i32.const 2))) + + (br_on_cast_fail $l structref (ref null $t3) (ref.null struct)) + (br_on_cast_fail $l structref (ref null $t3) (table.get (i32.const 3))) + (br_on_cast_fail $l structref (ref $t3) (table.get (i32.const 3))) + + (br_on_cast_fail $l structref (ref null $t4) (ref.null struct)) + (br_on_cast_fail $l structref (ref null $t4) (table.get (i32.const 4))) + (br_on_cast_fail $l structref (ref $t4) (table.get (i32.const 4))) + + ;; must succeed + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t0) (ref.null struct)))) + + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t1) (ref.null struct)))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t1) (table.get (i32.const 0))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t1) (table.get (i32.const 3))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t1) (table.get (i32.const 4))))) + + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (ref.null struct)))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (table.get (i32.const 0))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (table.get (i32.const 1))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (table.get (i32.const 3))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (table.get (i32.const 4))))) + + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (ref.null struct)))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (table.get (i32.const 0))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (table.get (i32.const 1))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (table.get (i32.const 2))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (table.get (i32.const 4))))) + + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (ref.null struct)))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (table.get (i32.const 0))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (table.get (i32.const 1))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (table.get (i32.const 2))))) + (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (table.get (i32.const 3))))) + + (return) + ) + (unreachable) + ) + + (func (export "test-canon") + (call $init) + (block $l (result structref) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 0))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 1))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 2))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 3))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 4))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 10))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 11))) + (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 12))) + + (br_on_cast_fail $l structref (ref $t1') (table.get (i32.const 1))) + (br_on_cast_fail $l structref (ref $t1') (table.get (i32.const 2))) + + (br_on_cast_fail $l structref (ref $t1) (table.get (i32.const 11))) + (br_on_cast_fail $l structref (ref $t1) (table.get (i32.const 12))) + + (br_on_cast_fail $l structref (ref $t2') (table.get (i32.const 2))) + + (br_on_cast_fail $l structref (ref $t2) (table.get (i32.const 12))) + + (return) + ) + (unreachable) + ) +) + +(invoke "test-sub") +(invoke "test-canon") + + +;; Cases of nullability + +(module + (type $t (struct)) + + (func (param (ref any)) (result (ref any)) + (block (result (ref $t)) (br_on_cast_fail 1 (ref any) (ref $t) (local.get 0))) + ) + (func (param (ref null any)) (result (ref null any)) + (block (result (ref $t)) (br_on_cast_fail 1 (ref null any) (ref $t) (local.get 0))) + ) + (func (param (ref null any)) (result (ref null any)) + (block (result (ref null $t)) (br_on_cast_fail 1 (ref null any) (ref null $t) (local.get 0))) + ) +) + +(assert_invalid + (module + (type $t (struct)) + (func (param (ref any)) (result (ref any)) + (block (result (ref $t)) (br_on_cast_fail 1 (ref null any) (ref null $t) (local.get 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type $t (struct)) + (func (param (ref any)) (result (ref any)) + (block (result (ref null $t)) (br_on_cast_fail 1 (ref any) (ref null $t) (local.get 0))) (ref.as_non_null) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type $t (struct)) + (func (param (ref null any)) (result (ref any)) + (block (result (ref $t)) (br_on_cast_fail 1 (ref null any) (ref $t) (local.get 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (result anyref) + (br_on_cast_fail 0 eqref anyref (unreachable)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (result anyref) + (br_on_cast_fail 0 structref arrayref (unreachable)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/call_ref.wast b/tests/requirement-engineering/gc-aot/wasm-apps/call_ref.wast new file mode 100644 index 00000000..42533959 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/call_ref.wast @@ -0,0 +1,208 @@ +(module + (type $ii (func (param i32) (result i32))) + + (func $apply (param $f (ref $ii)) (param $x i32) (result i32) + (call_ref $ii (local.get $x) (local.get $f)) + ) + + (func $f (type $ii) (i32.mul (local.get 0) (local.get 0))) + (func $g (type $ii) (i32.sub (i32.const 0) (local.get 0))) + + (elem declare func $f $g) + + (func (export "run") (param $x i32) (result i32) + (local $rf (ref null $ii)) + (local $rg (ref null $ii)) + (local.set $rf (ref.func $f)) + (local.set $rg (ref.func $g)) + (call_ref $ii (call_ref $ii (local.get $x) (local.get $rf)) (local.get $rg)) + ) + + (func (export "null") (result i32) + (call_ref $ii (i32.const 1) (ref.null $ii)) + ) + + ;; Recursion + + (type $ll (func (param i64) (result i64))) + (type $lll (func (param i64 i64) (result i64))) + + (elem declare func $fac) + (global $fac (ref $ll) (ref.func $fac)) + + (func $fac (export "fac") (type $ll) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get 0) + (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $fac)) + ) + ) + ) + ) + + (elem declare func $fac-acc) + (global $fac-acc (ref $lll) (ref.func $fac-acc)) + + (func $fac-acc (export "fac-acc") (type $lll) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 1)) + (else + (call_ref $lll + (i64.sub (local.get 0) (i64.const 1)) + (i64.mul (local.get 0) (local.get 1)) + (global.get $fac-acc) + ) + ) + ) + ) + + (elem declare func $fib) + (global $fib (ref $ll) (ref.func $fib)) + + (func $fib (export "fib") (type $ll) + (if (result i64) (i64.le_u (local.get 0) (i64.const 1)) + (then (i64.const 1)) + (else + (i64.add + (call_ref $ll (i64.sub (local.get 0) (i64.const 2)) (global.get $fib)) + (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $fib)) + ) + ) + ) + ) + + (elem declare func $even $odd) + (global $even (ref $ll) (ref.func $even)) + (global $odd (ref $ll) (ref.func $odd)) + + (func $even (export "even") (type $ll) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 44)) + (else (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $odd))) + ) + ) + (func $odd (export "odd") (type $ll) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 99)) + (else (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $even))) + ) + ) +) + +(assert_return (invoke "run" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "run" (i32.const 3)) (i32.const -9)) + +(assert_trap (invoke "null") "null function") + +(assert_return (invoke "fac" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fac" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac" (i64.const 5)) (i64.const 120)) +(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120)) +(assert_return + (invoke "fac-acc" (i64.const 25) (i64.const 1)) + (i64.const 7034535277573963776) +) + +(assert_return (invoke "fib" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fib" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fib" (i64.const 2)) (i64.const 2)) +(assert_return (invoke "fib" (i64.const 5)) (i64.const 8)) +(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946)) + +(assert_return (invoke "even" (i64.const 0)) (i64.const 44)) +(assert_return (invoke "even" (i64.const 1)) (i64.const 99)) +(assert_return (invoke "even" (i64.const 100)) (i64.const 44)) +(assert_return (invoke "even" (i64.const 77)) (i64.const 99)) +(assert_return (invoke "odd" (i64.const 0)) (i64.const 99)) +(assert_return (invoke "odd" (i64.const 1)) (i64.const 44)) +(assert_return (invoke "odd" (i64.const 200)) (i64.const 99)) +(assert_return (invoke "odd" (i64.const 77)) (i64.const 44)) + + +;; Unreachable typing. + +(module + (type $t (func)) + (func (export "unreachable") (result i32) + (unreachable) + (call_ref $t) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (elem declare func $f) + (type $t (func (param i32) (result i32))) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $f) + (call_ref $t) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (elem declare func $f) + (type $t (func (param i32) (result i32))) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i32.const 0) + (ref.func $f) + (call_ref $t) + (drop) + (i32.const 0) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(assert_invalid + (module + (elem declare func $f) + (type $t (func (param i32) (result i32))) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i64.const 0) + (ref.func $f) + (call_ref $t) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (elem declare func $f) + (type $t (func (param i32) (result i32))) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $f) + (call_ref $t) + (drop) + (i64.const 0) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (func $f (param $r externref) + (call_ref $t (local.get $r)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/extern.wast b/tests/requirement-engineering/gc-aot/wasm-apps/extern.wast new file mode 100644 index 00000000..9ef86506 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/extern.wast @@ -0,0 +1,54 @@ +(module + (type $ft (func)) + (type $st (struct)) + (type $at (array i8)) + + (table 10 anyref) + + (elem declare func $f) + (func $f) + + (func (export "init") (param $x externref) + (table.set (i32.const 0) (ref.null any)) + (table.set (i32.const 1) (ref.i31 (i32.const 7))) + (table.set (i32.const 2) (struct.new_default $st)) + (table.set (i32.const 3) (array.new_default $at (i32.const 0))) + (table.set (i32.const 4) (any.convert_extern (local.get $x))) + ) + + (func (export "internalize") (param externref) (result anyref) + (any.convert_extern (local.get 0)) + ) + (func (export "externalize") (param anyref) (result externref) + (extern.convert_any (local.get 0)) + ) + + (func (export "externalize-i") (param i32) (result externref) + (extern.convert_any (table.get (local.get 0))) + ) + (func (export "externalize-ii") (param i32) (result anyref) + (any.convert_extern (extern.convert_any (table.get (local.get 0)))) + ) +) + +(invoke "init" (ref.extern 0)) + +(assert_return (invoke "internalize" (ref.extern 1)) (ref.host 1)) +(assert_return (invoke "internalize" (ref.null extern)) (ref.null any)) + +(assert_return (invoke "externalize" (ref.host 2)) (ref.extern 2)) +(assert_return (invoke "externalize" (ref.null any)) (ref.null extern)) + +(assert_return (invoke "externalize-i" (i32.const 0)) (ref.null extern)) +(assert_return (invoke "externalize-i" (i32.const 1)) (ref.extern)) +(assert_return (invoke "externalize-i" (i32.const 2)) (ref.extern)) +(assert_return (invoke "externalize-i" (i32.const 3)) (ref.extern)) +(assert_return (invoke "externalize-i" (i32.const 4)) (ref.extern 0)) +(assert_return (invoke "externalize-i" (i32.const 5)) (ref.null extern)) + +(assert_return (invoke "externalize-ii" (i32.const 0)) (ref.null any)) +(assert_return (invoke "externalize-ii" (i32.const 1)) (ref.i31)) +(assert_return (invoke "externalize-ii" (i32.const 2)) (ref.struct)) +(assert_return (invoke "externalize-ii" (i32.const 3)) (ref.array)) +(assert_return (invoke "externalize-ii" (i32.const 4)) (ref.host 0)) +(assert_return (invoke "externalize-ii" (i32.const 5)) (ref.null any)) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/i31.wast b/tests/requirement-engineering/gc-aot/wasm-apps/i31.wast new file mode 100644 index 00000000..3b6c32fb --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/i31.wast @@ -0,0 +1,51 @@ +(module + (func (export "new") (param $i i32) (result (ref i31)) + (ref.i31 (local.get $i)) + ) + + (func (export "get_u") (param $i i32) (result i32) + (i31.get_u (ref.i31 (local.get $i))) + ) + (func (export "get_s") (param $i i32) (result i32) + (i31.get_s (ref.i31 (local.get $i))) + ) + + (func (export "get_u-null") (result i32) + (i31.get_u (ref.null i31)) + ) + (func (export "get_s-null") (result i32) + (i31.get_u (ref.null i31)) + ) + + (global $i (ref i31) (ref.i31 (i32.const 2))) + (global $m (mut (ref i31)) (ref.i31 (i32.const 3))) + (func (export "get_globals") (result i32 i32) + (i31.get_u (global.get $i)) + (i31.get_u (global.get $m)) + ) +) + +(assert_return (invoke "new" (i32.const 1)) (ref.i31)) + +(assert_return (invoke "get_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "get_u" (i32.const 100)) (i32.const 100)) +(assert_return (invoke "get_u" (i32.const -1)) (i32.const 0x7fff_ffff)) +(assert_return (invoke "get_u" (i32.const 0x3fff_ffff)) (i32.const 0x3fff_ffff)) +(assert_return (invoke "get_u" (i32.const 0x4000_0000)) (i32.const 0x4000_0000)) +(assert_return (invoke "get_u" (i32.const 0x7fff_ffff)) (i32.const 0x7fff_ffff)) +(assert_return (invoke "get_u" (i32.const 0xaaaa_aaaa)) (i32.const 0x2aaa_aaaa)) +(assert_return (invoke "get_u" (i32.const 0xcaaa_aaaa)) (i32.const 0x4aaa_aaaa)) + +(assert_return (invoke "get_s" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "get_s" (i32.const 100)) (i32.const 100)) +(assert_return (invoke "get_s" (i32.const -1)) (i32.const -1)) +(assert_return (invoke "get_s" (i32.const 0x3fff_ffff)) (i32.const 0x3fff_ffff)) +(assert_return (invoke "get_s" (i32.const 0x4000_0000)) (i32.const -0x4000_0000)) +(assert_return (invoke "get_s" (i32.const 0x7fff_ffff)) (i32.const -1)) +(assert_return (invoke "get_s" (i32.const 0xaaaa_aaaa)) (i32.const 0x2aaa_aaaa)) +(assert_return (invoke "get_s" (i32.const 0xcaaa_aaaa)) (i32.const 0xcaaa_aaaa)) + +(assert_trap (invoke "get_u-null") "null i31 reference") +(assert_trap (invoke "get_s-null") "null i31 reference") + +(assert_return (invoke "get_globals") (i32.const 2) (i32.const 3)) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/local_set.wast b/tests/requirement-engineering/gc-aot/wasm-apps/local_set.wast new file mode 100644 index 00000000..ce9cf77f --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/local_set.wast @@ -0,0 +1,362 @@ +;; Test `local.set` operator + +(module + ;; Typing + + (func (export "type-local-i32") (local i32) (local.set 0 (i32.const 0))) + (func (export "type-local-i64") (local i64) (local.set 0 (i64.const 0))) + (func (export "type-local-f32") (local f32) (local.set 0 (f32.const 0))) + (func (export "type-local-f64") (local f64) (local.set 0 (f64.const 0))) + + (func (export "type-param-i32") (param i32) (local.set 0 (i32.const 10))) + (func (export "type-param-i64") (param i64) (local.set 0 (i64.const 11))) + (func (export "type-param-f32") (param f32) (local.set 0 (f32.const 11.1))) + (func (export "type-param-f64") (param f64) (local.set 0 (f64.const 12.2))) + + (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) + (local.set 0 (i64.const 0)) + (local.set 1 (f32.const 0)) + (local.set 2 (f64.const 0)) + (local.set 3 (i32.const 0)) + (local.set 4 (i32.const 0)) + (local.set 5 (f32.const 0)) + (local.set 6 (i64.const 0)) + (local.set 7 (i64.const 0)) + (local.set 8 (f64.const 0)) + ) + + ;; Writing + + (func (export "write") (param i64 f32 f64 i32 i32) (result i64) + (local f32 i64 i64 f64) + (local.set 1 (f32.const -0.3)) + (local.set 3 (i32.const 40)) + (local.set 4 (i32.const -7)) + (local.set 5 (f32.const 5.5)) + (local.set 6 (i64.const 6)) + (local.set 8 (f64.const 8)) + (i64.trunc_f64_s + (f64.add + (f64.convert_i64_u (local.get 0)) + (f64.add + (f64.promote_f32 (local.get 1)) + (f64.add + (local.get 2) + (f64.add + (f64.convert_i32_u (local.get 3)) + (f64.add + (f64.convert_i32_s (local.get 4)) + (f64.add + (f64.promote_f32 (local.get 5)) + (f64.add + (f64.convert_i64_u (local.get 6)) + (f64.add + (f64.convert_i64_u (local.get 7)) + (local.get 8) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + + ;; As parameter of control constructs and instructions + + (func (export "as-block-value") (param i32) + (block (local.set 0 (i32.const 1))) + ) + (func (export "as-loop-value") (param i32) + (loop (local.set 0 (i32.const 3))) + ) + + (func (export "as-br-value") (param i32) + (block (br 0 (local.set 0 (i32.const 9)))) + ) + (func (export "as-br_if-value") (param i32) + (block + (br_if 0 (local.set 0 (i32.const 8)) (i32.const 1)) + ) + ) + (func (export "as-br_if-value-cond") (param i32) + (block + (br_if 0 (i32.const 6) (local.set 0 (i32.const 9))) + ) + ) + (func (export "as-br_table-value") (param i32) + (block + (br_table 0 (local.set 0 (i32.const 10)) (i32.const 1)) + ) + ) + + (func (export "as-return-value") (param i32) + (return (local.set 0 (i32.const 7))) + ) + + (func (export "as-if-then") (param i32) + (if (local.get 0) (then (local.set 0 (i32.const 3)))) + ) + (func (export "as-if-else") (param i32) + (if (local.get 0) (then) (else (local.set 0 (i32.const 1)))) + ) +) + +(assert_return (invoke "type-local-i32")) +(assert_return (invoke "type-local-i64")) +(assert_return (invoke "type-local-f32")) +(assert_return (invoke "type-local-f64")) + +(assert_return (invoke "type-param-i32" (i32.const 2))) +(assert_return (invoke "type-param-i64" (i64.const 3))) +(assert_return (invoke "type-param-f32" (f32.const 4.4))) +(assert_return (invoke "type-param-f64" (f64.const 5.5))) + +(assert_return (invoke "as-block-value" (i32.const 0))) +(assert_return (invoke "as-loop-value" (i32.const 0))) + +(assert_return (invoke "as-br-value" (i32.const 0))) +(assert_return (invoke "as-br_if-value" (i32.const 0))) +(assert_return (invoke "as-br_if-value-cond" (i32.const 0))) +(assert_return (invoke "as-br_table-value" (i32.const 0))) + +(assert_return (invoke "as-return-value" (i32.const 0))) + +(assert_return (invoke "as-if-then" (i32.const 1))) +(assert_return (invoke "as-if-else" (i32.const 0))) + +(assert_return + (invoke "type-mixed" + (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5) + ) +) + +(assert_return + (invoke "write" + (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5) + ) + (i64.const 56) +) + + +;; Invalid typing of access to locals + + +(assert_invalid + (module (func $type-local-arg-void-vs-num (local i32) (local.set 0 (nop)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-arg-num-vs-num (local i32) (local.set 0 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-arg-num-vs-num (local f32) (local.set 0 (f64.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-arg-num-vs-num (local f64 i64) (local.set 1 (f64.const 0)))) + "type mismatch" +) + + +;; Invalid typing of access to parameters + + +(assert_invalid + (module (func $type-param-arg-void-vs-num (param i32) (local.set 0 (nop)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-arg-num-vs-num (param i32) (local.set 0 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-arg-num-vs-num (param f32) (local.set 0 (f64.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-arg-num-vs-num (param f64 i64) (local.set 1 (f64.const 0)))) + "type mismatch" +) + +(assert_invalid + (module + (func $type-param-arg-empty-vs-num (param i32) + (local.set 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-block (param i32) + (i32.const 0) + (block (local.set 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-loop (param i32) + (i32.const 0) + (loop (local.set 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-then (param i32) + (i32.const 0) + (if (i32.const 1) (then (local.set 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-else (param i32) + (i32.const 0) + (if (result i32) (i32.const 0) (then (i32.const 0)) (else (local.set 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-br (param i32) + (i32.const 0) + (block (br 0 (local.set 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-br_if (param i32) + (i32.const 0) + (block (br_if 0 (local.set 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-br_table (param i32) + (i32.const 0) + (block (br_table 0 (local.set 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-return (param i32) + (return (local.set 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-select (param i32) + (select (local.set 0) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-call (param i32) + (call 1 (local.set 0)) + ) + (func (param i32) (result i32) (local.get 0)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32) (result i32) (local.get 0)) + (type $sig (func (param i32) (result i32))) + (table funcref (elem $f)) + (func $type-param-arg-empty-vs-num-in-call_indirect (param i32) + (block (result i32) + (call_indirect (type $sig) + (local.set 0) (i32.const 0) + ) + ) + ) + ) + "type mismatch" +) + + +;; Invalid typing of access to mixed args + +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (local.set 1 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.set 1 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.set 1 (i64.const 0)))) + "type mismatch" +) + + +;; local.set should have no retval + +(assert_invalid + (module (func $type-empty-vs-i32 (param i32) (result i32) (local.set 0 (i32.const 1)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-vs-i64 (param i64) (result i64) (local.set 0 (i64.const 1)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-vs-f32 (param f32) (result f32) (local.set 0 (f32.const 1)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-vs-f64 (param f64) (result f64) (local.set 0 (f64.const 1)))) + "type mismatch" +) + + +;; Invalid local index + +(assert_invalid + (module (func $unbound-local (local i32 i64) (local.set 3 (i32.const 0)))) + "unknown local" +) +(assert_invalid + (module (func $large-local (local i32 i64) (local.set 14324343 (i32.const 0)))) + "unknown local" +) + +(assert_invalid + (module (func $unbound-param (param i32 i64) (local.set 2 (i32.const 0)))) + "unknown local" +) +(assert_invalid + (module (func $large-param (param i32 i64) (local.set 714324343 (i32.const 0)))) + "unknown local" +) + +(assert_invalid + (module (func $unbound-mixed (param i32) (local i32 i64) (local.set 3 (i32.const 0)))) + "unknown local" +) +(assert_invalid + (module (func $large-mixed (param i64) (local i32 i64) (local.set 214324343 (i32.const 0)))) + "unknown local" +) + diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/local_tee.wast b/tests/requirement-engineering/gc-aot/wasm-apps/local_tee.wast new file mode 100644 index 00000000..a158f0c7 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/local_tee.wast @@ -0,0 +1,639 @@ +;; Test `local.tee` operator + +(module + ;; Typing + + (func (export "type-local-i32") (result i32) (local i32) (local.tee 0 (i32.const 0))) + (func (export "type-local-i64") (result i64) (local i64) (local.tee 0 (i64.const 0))) + (func (export "type-local-f32") (result f32) (local f32) (local.tee 0 (f32.const 0))) + (func (export "type-local-f64") (result f64) (local f64) (local.tee 0 (f64.const 0))) + + (func (export "type-param-i32") (param i32) (result i32) (local.tee 0 (i32.const 10))) + (func (export "type-param-i64") (param i64) (result i64) (local.tee 0 (i64.const 11))) + (func (export "type-param-f32") (param f32) (result f32) (local.tee 0 (f32.const 11.1))) + (func (export "type-param-f64") (param f64) (result f64) (local.tee 0 (f64.const 12.2))) + + (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) + (drop (i64.eqz (local.tee 0 (i64.const 0)))) + (drop (f32.neg (local.tee 1 (f32.const 0)))) + (drop (f64.neg (local.tee 2 (f64.const 0)))) + (drop (i32.eqz (local.tee 3 (i32.const 0)))) + (drop (i32.eqz (local.tee 4 (i32.const 0)))) + (drop (f32.neg (local.tee 5 (f32.const 0)))) + (drop (i64.eqz (local.tee 6 (i64.const 0)))) + (drop (i64.eqz (local.tee 7 (i64.const 0)))) + (drop (f64.neg (local.tee 8 (f64.const 0)))) + ) + + ;; Writing + + (func (export "write") (param i64 f32 f64 i32 i32) (result i64) (local f32 i64 i64 f64) + (drop (local.tee 1 (f32.const -0.3))) + (drop (local.tee 3 (i32.const 40))) + (drop (local.tee 4 (i32.const -7))) + (drop (local.tee 5 (f32.const 5.5))) + (drop (local.tee 6 (i64.const 6))) + (drop (local.tee 8 (f64.const 8))) + (i64.trunc_f64_s + (f64.add + (f64.convert_i64_u (local.get 0)) + (f64.add + (f64.promote_f32 (local.get 1)) + (f64.add + (local.get 2) + (f64.add + (f64.convert_i32_u (local.get 3)) + (f64.add + (f64.convert_i32_s (local.get 4)) + (f64.add + (f64.promote_f32 (local.get 5)) + (f64.add + (f64.convert_i64_u (local.get 6)) + (f64.add + (f64.convert_i64_u (local.get 7)) + (local.get 8) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + + ;; Result + + (func (export "result") (param i64 f32 f64 i32 i32) (result f64) + (local f32 i64 i64 f64) + (f64.add + (f64.convert_i64_u (local.tee 0 (i64.const 1))) + (f64.add + (f64.promote_f32 (local.tee 1 (f32.const 2))) + (f64.add + (local.tee 2 (f64.const 3.3)) + (f64.add + (f64.convert_i32_u (local.tee 3 (i32.const 4))) + (f64.add + (f64.convert_i32_s (local.tee 4 (i32.const 5))) + (f64.add + (f64.promote_f32 (local.tee 5 (f32.const 5.5))) + (f64.add + (f64.convert_i64_u (local.tee 6 (i64.const 6))) + (f64.add + (f64.convert_i64_u (local.tee 7 (i64.const 0))) + (local.tee 8 (f64.const 8)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + + (func $dummy) + + (func (export "as-block-first") (param i32) (result i32) + (block (result i32) (local.tee 0 (i32.const 1)) (call $dummy)) + ) + (func (export "as-block-mid") (param i32) (result i32) + (block (result i32) (call $dummy) (local.tee 0 (i32.const 1)) (call $dummy)) + ) + (func (export "as-block-last") (param i32) (result i32) + (block (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 1))) + ) + + (func (export "as-loop-first") (param i32) (result i32) + (loop (result i32) (local.tee 0 (i32.const 3)) (call $dummy)) + ) + (func (export "as-loop-mid") (param i32) (result i32) + (loop (result i32) (call $dummy) (local.tee 0 (i32.const 4)) (call $dummy)) + ) + (func (export "as-loop-last") (param i32) (result i32) + (loop (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 5))) + ) + + (func (export "as-br-value") (param i32) (result i32) + (block (result i32) (br 0 (local.tee 0 (i32.const 9)))) + ) + + (func (export "as-br_if-cond") (param i32) + (block (br_if 0 (local.tee 0 (i32.const 1)))) + ) + (func (export "as-br_if-value") (param i32) (result i32) + (block (result i32) + (drop (br_if 0 (local.tee 0 (i32.const 8)) (i32.const 1))) (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (param i32) (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (local.tee 0 (i32.const 9)))) (i32.const 7) + ) + ) + + (func (export "as-br_table-index") (param i32) + (block (br_table 0 0 0 (local.tee 0 (i32.const 0)))) + ) + (func (export "as-br_table-value") (param i32) (result i32) + (block (result i32) + (br_table 0 0 0 (local.tee 0 (i32.const 10)) (i32.const 1)) (i32.const 7) + ) + ) + (func (export "as-br_table-value-index") (param i32) (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (local.tee 0 (i32.const 11))) (i32.const 7) + ) + ) + + (func (export "as-return-value") (param i32) (result i32) + (return (local.tee 0 (i32.const 7))) + ) + + (func (export "as-if-cond") (param i32) (result i32) + (if (result i32) (local.tee 0 (i32.const 2)) + (then (i32.const 0)) (else (i32.const 1)) + ) + ) + (func (export "as-if-then") (param i32) (result i32) + (if (result i32) (local.get 0) + (then (local.tee 0 (i32.const 3))) (else (local.get 0)) + ) + ) + (func (export "as-if-else") (param i32) (result i32) + (if (result i32) (local.get 0) + (then (local.get 0)) (else (local.tee 0 (i32.const 4))) + ) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (select (local.tee 0 (i32.const 5)) (local.get 0) (local.get 1)) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (select (local.get 0) (local.tee 0 (i32.const 6)) (local.get 1)) + ) + (func (export "as-select-cond") (param i32) (result i32) + (select (i32.const 0) (i32.const 1) (local.tee 0 (i32.const 7))) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (param i32) (result i32) + (call $f (local.tee 0 (i32.const 12)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-call-mid") (param i32) (result i32) + (call $f (i32.const 1) (local.tee 0 (i32.const 13)) (i32.const 3)) + ) + (func (export "as-call-last") (param i32) (result i32) + (call $f (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 14))) + ) + + (type $sig (func (param i32 i32 i32) (result i32))) + (table funcref (elem $f)) + (func (export "as-call_indirect-first") (param i32) (result i32) + (call_indirect (type $sig) + (local.tee 0 (i32.const 1)) (i32.const 2) (i32.const 3) (i32.const 0) + ) + ) + (func (export "as-call_indirect-mid") (param i32) (result i32) + (call_indirect (type $sig) + (i32.const 1) (local.tee 0 (i32.const 2)) (i32.const 3) (i32.const 0) + ) + ) + (func (export "as-call_indirect-last") (param i32) (result i32) + (call_indirect (type $sig) + (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 3)) (i32.const 0) + ) + ) + (func (export "as-call_indirect-index") (param i32) (result i32) + (call_indirect (type $sig) + (i32.const 1) (i32.const 2) (i32.const 3) (local.tee 0 (i32.const 0)) + ) + ) + + (func (export "as-local.set-value") (local i32) + (local.set 0 (local.tee 0 (i32.const 1))) + ) + (func (export "as-local.tee-value") (param i32) (result i32) + (local.tee 0 (local.tee 0 (i32.const 1))) + ) + (global $g (mut i32) (i32.const 0)) + (func (export "as-global.set-value") (local i32) + (global.set $g (local.tee 0 (i32.const 1))) + ) + + (memory 1) + (func (export "as-load-address") (param i32) (result i32) + (i32.load (local.tee 0 (i32.const 1))) + ) + (func (export "as-loadN-address") (param i32) (result i32) + (i32.load8_s (local.tee 0 (i32.const 3))) + ) + + (func (export "as-store-address") (param i32) + (i32.store (local.tee 0 (i32.const 30)) (i32.const 7)) + ) + (func (export "as-store-value") (param i32) + (i32.store (i32.const 2) (local.tee 0 (i32.const 1))) + ) + + (func (export "as-storeN-address") (param i32) + (i32.store8 (local.tee 0 (i32.const 1)) (i32.const 7)) + ) + (func (export "as-storeN-value") (param i32) + (i32.store16 (i32.const 2) (local.tee 0 (i32.const 1))) + ) + + (func (export "as-unary-operand") (param f32) (result f32) + (f32.neg (local.tee 0 (f32.const nan:0x0f1e2))) + ) + + (func (export "as-binary-left") (param i32) (result i32) + (i32.add (local.tee 0 (i32.const 3)) (i32.const 10)) + ) + (func (export "as-binary-right") (param i32) (result i32) + (i32.sub (i32.const 10) (local.tee 0 (i32.const 4))) + ) + + (func (export "as-test-operand") (param i32) (result i32) + (i32.eqz (local.tee 0 (i32.const 0))) + ) + + (func (export "as-compare-left") (param i32) (result i32) + (i32.le_s (local.tee 0 (i32.const 43)) (i32.const 10)) + ) + (func (export "as-compare-right") (param i32) (result i32) + (i32.ne (i32.const 10) (local.tee 0 (i32.const 42))) + ) + + (func (export "as-convert-operand") (param i64) (result i32) + (i32.wrap_i64 (local.tee 0 (i64.const 41))) + ) + + (func (export "as-memory.grow-size") (param i32) (result i32) + (memory.grow (local.tee 0 (i32.const 40))) + ) + +) + +(assert_return (invoke "type-local-i32") (i32.const 0)) +(assert_return (invoke "type-local-i64") (i64.const 0)) +(assert_return (invoke "type-local-f32") (f32.const 0)) +(assert_return (invoke "type-local-f64") (f64.const 0)) + +(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 10)) +(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 11)) +(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 11.1)) +(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 12.2)) + +(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-block-last" (i32.const 0)) (i32.const 1)) + +(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 4)) +(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 5)) + +(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 9)) + +(assert_return (invoke "as-br_if-cond" (i32.const 0))) +(assert_return (invoke "as-br_if-value" (i32.const 0)) (i32.const 8)) +(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 6)) + +(assert_return (invoke "as-br_table-index" (i32.const 0))) +(assert_return (invoke "as-br_table-value" (i32.const 0)) (i32.const 10)) +(assert_return (invoke "as-br_table-value-index" (i32.const 0)) (i32.const 6)) + +(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 7)) + +(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 4)) + +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 5)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 6)) +(assert_return (invoke "as-select-cond" (i32.const 0)) (i32.const 0)) + +(assert_return (invoke "as-call-first" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "as-call-mid" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "as-call-last" (i32.const 0)) (i32.const -1)) + +(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "as-call_indirect-index" (i32.const 0)) (i32.const -1)) + +(assert_return (invoke "as-local.set-value")) +(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-global.set-value")) + +(assert_return (invoke "as-load-address" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loadN-address" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-store-address" (i32.const 0))) +(assert_return (invoke "as-store-value" (i32.const 0))) +(assert_return (invoke "as-storeN-address" (i32.const 0))) +(assert_return (invoke "as-storeN-value" (i32.const 0))) + +(assert_return (invoke "as-unary-operand" (f32.const 0)) (f32.const -nan:0x0f1e2)) +(assert_return (invoke "as-binary-left" (i32.const 0)) (i32.const 13)) +(assert_return (invoke "as-binary-right" (i32.const 0)) (i32.const 6)) +(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-convert-operand" (i64.const 0)) (i32.const 41)) +(assert_return (invoke "as-memory.grow-size" (i32.const 0)) (i32.const 1)) + +(assert_return + (invoke "type-mixed" + (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5) + ) +) + +(assert_return + (invoke "write" + (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5) + ) + (i64.const 56) +) + +(assert_return + (invoke "result" + (i64.const -1) (f32.const -2) (f64.const -3.3) (i32.const -4) (i32.const -5) + ) + (f64.const 34.8) +) + + +;; Invalid typing of access to locals + +(assert_invalid + (module (func $type-local-num-vs-num (result i64) (local i32) (local.tee 0 (i32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.tee 0 (f32.const 0))))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.tee 1 (i64.const 0))))) + "type mismatch" +) + +(assert_invalid + (module (func $type-local-arg-void-vs-num (local i32) (local.tee 0 (nop)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-arg-num-vs-num (local i32) (local.tee 0 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-arg-num-vs-num (local f32) (local.tee 0 (f64.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-arg-num-vs-num (local f64 i64) (local.tee 1 (f64.const 0)))) + "type mismatch" +) + + +;; Invalid typing of access to parameters + +(assert_invalid + (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1)))) + "type mismatch" +) + +(assert_invalid + (module (func $type-param-arg-void-vs-num (param i32) (local.tee 0 (nop)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-arg-num-vs-num (param i32) (local.tee 0 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-arg-num-vs-num (param f32) (local.tee 0 (f64.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-arg-num-vs-num (param f64 i64) (local.tee 1 (f64.const 0)))) + "type mismatch" +) + +(assert_invalid + (module + (func $type-param-arg-empty-vs-num (param i32) + (local.tee 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-block (param i32) + (i32.const 0) + (block (local.tee 0) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-loop (param i32) + (i32.const 0) + (loop (local.tee 0) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-then (param i32) + (i32.const 0) (i32.const 0) + (if (then (local.tee 0) (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-else (param i32) + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (local.tee 0))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-br (param i32) + (i32.const 0) + (block (br 0 (local.tee 0)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-br_if (param i32) + (i32.const 0) + (block (br_if 0 (local.tee 0) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-br_table (param i32) + (i32.const 0) + (block (br_table 0 (local.tee 0)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-return (param i32) + (return (local.tee 0)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-select (param i32) + (select (local.tee 0) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-call (param i32) + (call 1 (local.tee 0)) (drop) + ) + (func (param i32) (result i32) (local.get 0)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32) (result i32) (local.get 0)) + (type $sig (func (param i32) (result i32))) + (table funcref (elem $f)) + (func $type-param-arg-empty-vs-num-in-call_indirect (param i32) + (block (result i32) + (call_indirect (type $sig) + (local.tee 0) (i32.const 0) + ) + (drop) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-local.set (param i32) + (local.set 0 (local.tee 0)) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-param-arg-empty-vs-num-in-local.tee (param i32) + (local.tee 0 (local.tee 0)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-param-arg-empty-vs-num-in-global.set (param i32) + (global.set $x (local.tee 0)) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-param-arg-empty-vs-num-in-memory.grow (param i32) + (memory.grow (local.tee 0)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-param-arg-empty-vs-num-in-load (param i32) + (i32.load (local.tee 0)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-param-arg-empty-vs-num-in-store (param i32) + (i32.store (local.tee 0) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (local.tee 1 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.tee 1 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.tee 1 (i64.const 0)))) + "type mismatch" +) + + +;; Invalid local index + +(assert_invalid + (module (func $unbound-local (local i32 i64) (local.tee 3 (i32.const 0)) drop)) + "unknown local" +) +(assert_invalid + (module (func $large-local (local i32 i64) (local.tee 14324343 (i32.const 0)) drop)) + "unknown local" +) + +(assert_invalid + (module (func $unbound-param (param i32 i64) (local.tee 2 (i32.const 0)) drop)) + "unknown local" +) +(assert_invalid + (module (func $large-param (param i32 i64) (local.tee 714324343 (i32.const 0)) drop)) + "unknown local" +) + +(assert_invalid + (module (func $unbound-mixed (param i32) (local i32 i64) (local.tee 3 (i32.const 0)) drop)) + "unknown local" +) +(assert_invalid + (module (func $large-mixed (param i64) (local i32 i64) (local.tee 214324343 (i32.const 0)) drop)) + "unknown local" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/ref_cast.wast b/tests/requirement-engineering/gc-aot/wasm-apps/ref_cast.wast new file mode 100644 index 00000000..8e354311 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/ref_cast.wast @@ -0,0 +1,186 @@ +;; Abstract Types + +(module + (type $ft (func)) + (type $st (struct)) + (type $at (array i8)) + + (table 10 anyref) + + (elem declare func $f) + (func $f) + + (func (export "init") (param $x externref) + (table.set (i32.const 0) (ref.null any)) + (table.set (i32.const 1) (ref.i31 (i32.const 7))) + (table.set (i32.const 2) (struct.new_default $st)) + (table.set (i32.const 3) (array.new_default $at (i32.const 0))) + (table.set (i32.const 4) (any.convert_extern (local.get $x))) + (table.set (i32.const 5) (ref.null i31)) + (table.set (i32.const 6) (ref.null struct)) + (table.set (i32.const 7) (ref.null none)) + ) + + (func (export "ref_cast_non_null") (param $i i32) + (drop (ref.as_non_null (table.get (local.get $i)))) + (drop (ref.cast (ref null any) (table.get (local.get $i)))) + ) + (func (export "ref_cast_null") (param $i i32) + (drop (ref.cast anyref (table.get (local.get $i)))) + (drop (ref.cast structref (table.get (local.get $i)))) + (drop (ref.cast arrayref (table.get (local.get $i)))) + (drop (ref.cast i31ref (table.get (local.get $i)))) + (drop (ref.cast nullref (table.get (local.get $i)))) + ) + (func (export "ref_cast_i31") (param $i i32) + (drop (ref.cast (ref i31) (table.get (local.get $i)))) + (drop (ref.cast i31ref (table.get (local.get $i)))) + ) + (func (export "ref_cast_struct") (param $i i32) + (drop (ref.cast (ref struct) (table.get (local.get $i)))) + (drop (ref.cast structref (table.get (local.get $i)))) + ) + (func (export "ref_cast_array") (param $i i32) + (drop (ref.cast (ref array) (table.get (local.get $i)))) + (drop (ref.cast arrayref (table.get (local.get $i)))) + ) +) + +(invoke "init" (ref.extern 0)) + +(assert_trap (invoke "ref_cast_non_null" (i32.const 0)) "null reference") +(assert_return (invoke "ref_cast_non_null" (i32.const 1))) +(assert_return (invoke "ref_cast_non_null" (i32.const 2))) +(assert_return (invoke "ref_cast_non_null" (i32.const 3))) +(assert_return (invoke "ref_cast_non_null" (i32.const 4))) +(assert_trap (invoke "ref_cast_non_null" (i32.const 5)) "null reference") +(assert_trap (invoke "ref_cast_non_null" (i32.const 6)) "null reference") +(assert_trap (invoke "ref_cast_non_null" (i32.const 7)) "null reference") + +(assert_return (invoke "ref_cast_null" (i32.const 0))) +(assert_trap (invoke "ref_cast_null" (i32.const 1)) "cast failure") +(assert_trap (invoke "ref_cast_null" (i32.const 2)) "cast failure") +(assert_trap (invoke "ref_cast_null" (i32.const 3)) "cast failure") +(assert_trap (invoke "ref_cast_null" (i32.const 4)) "cast failure") +(assert_return (invoke "ref_cast_null" (i32.const 5))) +(assert_return (invoke "ref_cast_null" (i32.const 6))) +(assert_return (invoke "ref_cast_null" (i32.const 7))) + +(assert_trap (invoke "ref_cast_i31" (i32.const 0)) "cast failure") +(assert_return (invoke "ref_cast_i31" (i32.const 1))) +(assert_trap (invoke "ref_cast_i31" (i32.const 2)) "cast failure") +(assert_trap (invoke "ref_cast_i31" (i32.const 3)) "cast failure") +(assert_trap (invoke "ref_cast_i31" (i32.const 4)) "cast failure") +(assert_trap (invoke "ref_cast_i31" (i32.const 5)) "cast failure") +(assert_trap (invoke "ref_cast_i31" (i32.const 6)) "cast failure") +(assert_trap (invoke "ref_cast_i31" (i32.const 7)) "cast failure") + +(assert_trap (invoke "ref_cast_struct" (i32.const 0)) "cast failure") +(assert_trap (invoke "ref_cast_struct" (i32.const 1)) "cast failure") +(assert_return (invoke "ref_cast_struct" (i32.const 2))) +(assert_trap (invoke "ref_cast_struct" (i32.const 3)) "cast failure") +(assert_trap (invoke "ref_cast_struct" (i32.const 4)) "cast failure") +(assert_trap (invoke "ref_cast_struct" (i32.const 5)) "cast failure") +(assert_trap (invoke "ref_cast_struct" (i32.const 6)) "cast failure") +(assert_trap (invoke "ref_cast_struct" (i32.const 7)) "cast failure") + +(assert_trap (invoke "ref_cast_array" (i32.const 0)) "cast failure") +(assert_trap (invoke "ref_cast_array" (i32.const 1)) "cast failure") +(assert_trap (invoke "ref_cast_array" (i32.const 2)) "cast failure") +(assert_return (invoke "ref_cast_array" (i32.const 3))) +(assert_trap (invoke "ref_cast_array" (i32.const 4)) "cast failure") +(assert_trap (invoke "ref_cast_array" (i32.const 5)) "cast failure") +(assert_trap (invoke "ref_cast_array" (i32.const 6)) "cast failure") +(assert_trap (invoke "ref_cast_array" (i32.const 7)) "cast failure") + + +;; Concrete Types + +(module + (type $t0 (sub (struct))) + (type $t1 (sub $t0 (struct (field i32)))) + (type $t1' (sub $t0 (struct (field i32)))) + (type $t2 (sub $t1 (struct (field i32 i32)))) + (type $t2' (sub $t1' (struct (field i32 i32)))) + (type $t3 (sub $t0 (struct (field i32 i32)))) + (type $t0' (sub $t0 (struct))) + (type $t4 (sub $t0' (struct (field i32 i32)))) + + (table 20 (ref null struct)) + + (func $init + (table.set (i32.const 0) (struct.new_default $t0)) + (table.set (i32.const 10) (struct.new_default $t0)) + (table.set (i32.const 1) (struct.new_default $t1)) + (table.set (i32.const 11) (struct.new_default $t1')) + (table.set (i32.const 2) (struct.new_default $t2)) + (table.set (i32.const 12) (struct.new_default $t2')) + (table.set (i32.const 3) (struct.new_default $t3)) + (table.set (i32.const 4) (struct.new_default $t4)) + ) + + (func (export "test-sub") + (call $init) + + (drop (ref.cast (ref null $t0) (ref.null struct))) + (drop (ref.cast (ref null $t0) (table.get (i32.const 0)))) + (drop (ref.cast (ref null $t0) (table.get (i32.const 1)))) + (drop (ref.cast (ref null $t0) (table.get (i32.const 2)))) + (drop (ref.cast (ref null $t0) (table.get (i32.const 3)))) + (drop (ref.cast (ref null $t0) (table.get (i32.const 4)))) + + (drop (ref.cast (ref null $t0) (ref.null struct))) + (drop (ref.cast (ref null $t1) (table.get (i32.const 1)))) + (drop (ref.cast (ref null $t1) (table.get (i32.const 2)))) + + (drop (ref.cast (ref null $t0) (ref.null struct))) + (drop (ref.cast (ref null $t2) (table.get (i32.const 2)))) + + (drop (ref.cast (ref null $t0) (ref.null struct))) + (drop (ref.cast (ref null $t3) (table.get (i32.const 3)))) + + (drop (ref.cast (ref null $t4) (table.get (i32.const 4)))) + + (drop (ref.cast (ref $t0) (table.get (i32.const 0)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 1)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 2)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 3)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 4)))) + + (drop (ref.cast (ref $t1) (table.get (i32.const 1)))) + (drop (ref.cast (ref $t1) (table.get (i32.const 2)))) + + (drop (ref.cast (ref $t2) (table.get (i32.const 2)))) + + (drop (ref.cast (ref $t3) (table.get (i32.const 3)))) + + (drop (ref.cast (ref $t4) (table.get (i32.const 4)))) + ) + + (func (export "test-canon") + (call $init) + + (drop (ref.cast (ref $t0) (table.get (i32.const 0)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 1)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 2)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 3)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 4)))) + + (drop (ref.cast (ref $t0) (table.get (i32.const 10)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 11)))) + (drop (ref.cast (ref $t0) (table.get (i32.const 12)))) + + (drop (ref.cast (ref $t1') (table.get (i32.const 1)))) + (drop (ref.cast (ref $t1') (table.get (i32.const 2)))) + + (drop (ref.cast (ref $t1) (table.get (i32.const 11)))) + (drop (ref.cast (ref $t1) (table.get (i32.const 12)))) + + (drop (ref.cast (ref $t2') (table.get (i32.const 2)))) + + (drop (ref.cast (ref $t2) (table.get (i32.const 12)))) + ) +) + +(invoke "test-sub") +(invoke "test-canon") diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/ref_eq.wast b/tests/requirement-engineering/gc-aot/wasm-apps/ref_eq.wast new file mode 100644 index 00000000..001efd69 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/ref_eq.wast @@ -0,0 +1,168 @@ +(module + (type $st (sub (struct))) + (type $st' (sub (struct (field i32)))) + (type $at (array i8)) + (type $st-sub1 (sub $st (struct))) + (type $st-sub2 (sub $st (struct))) + (type $st'-sub1 (sub $st' (struct (field i32)))) + (type $st'-sub2 (sub $st' (struct (field i32)))) + + (table 20 (ref null eq)) + + (func (export "init") + (table.set (i32.const 0) (ref.null eq)) + (table.set (i32.const 1) (ref.null i31)) + (table.set (i32.const 2) (ref.i31 (i32.const 7))) + (table.set (i32.const 3) (ref.i31 (i32.const 7))) + (table.set (i32.const 4) (ref.i31 (i32.const 8))) + (table.set (i32.const 5) (struct.new_default $st)) + (table.set (i32.const 6) (struct.new_default $st)) + (table.set (i32.const 7) (array.new_default $at (i32.const 0))) + (table.set (i32.const 8) (array.new_default $at (i32.const 0))) + ) + + (func (export "eq") (param $i i32) (param $j i32) (result i32) + (ref.eq (table.get (local.get $i)) (table.get (local.get $j))) + ) +) + +(invoke "init") + +(assert_return (invoke "eq" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 8)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 8)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 2) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 2)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 3)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 8)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 3) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 2)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 3)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 8)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 4) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 4)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 8)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 5) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 5)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 8)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 6) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 6)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 8)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 7) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 7)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 8)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 8) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 8)) (i32.const 1)) + +(assert_invalid + (module + (func (export "eq") (param $r (ref any)) (result i32) + (ref.eq (local.get $r) (local.get $r)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (export "eq") (param $r (ref null any)) (result i32) + (ref.eq (local.get $r) (local.get $r)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (export "eq") (param $r (ref func)) (result i32) + (ref.eq (local.get $r) (local.get $r)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (export "eq") (param $r (ref null func)) (result i32) + (ref.eq (local.get $r) (local.get $r)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (export "eq") (param $r (ref extern)) (result i32) + (ref.eq (local.get $r) (local.get $r)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (export "eq") (param $r (ref null extern)) (result i32) + (ref.eq (local.get $r) (local.get $r)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/ref_test.wast b/tests/requirement-engineering/gc-aot/wasm-apps/ref_test.wast new file mode 100644 index 00000000..e0aa49ed --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/ref_test.wast @@ -0,0 +1,331 @@ +;; Abstract Types + +(module + (type $ft (func)) + (type $st (struct)) + (type $at (array i8)) + + (table $ta 10 anyref) + (table $tf 10 funcref) + (table $te 10 externref) + + (elem declare func $f) + (func $f) + + (func (export "init") (param $x externref) + (table.set $ta (i32.const 0) (ref.null any)) + (table.set $ta (i32.const 1) (ref.null struct)) + (table.set $ta (i32.const 2) (ref.null none)) + (table.set $ta (i32.const 3) (ref.i31 (i32.const 7))) + (table.set $ta (i32.const 4) (struct.new_default $st)) + (table.set $ta (i32.const 5) (array.new_default $at (i32.const 0))) + (table.set $ta (i32.const 6) (any.convert_extern (local.get $x))) + (table.set $ta (i32.const 7) (any.convert_extern (ref.null extern))) + + (table.set $tf (i32.const 0) (ref.null nofunc)) + (table.set $tf (i32.const 1) (ref.null func)) + (table.set $tf (i32.const 2) (ref.func $f)) + + (table.set $te (i32.const 0) (ref.null noextern)) + (table.set $te (i32.const 1) (ref.null extern)) + (table.set $te (i32.const 2) (local.get $x)) + (table.set $te (i32.const 3) (extern.convert_any (ref.i31 (i32.const 8)))) + (table.set $te (i32.const 4) (extern.convert_any (struct.new_default $st))) + (table.set $te (i32.const 5) (extern.convert_any (ref.null any))) + ) + + (func (export "ref_test_null_data") (param $i i32) (result i32) + (i32.add + (ref.is_null (table.get $ta (local.get $i))) + (ref.test nullref (table.get $ta (local.get $i))) + ) + ) + (func (export "ref_test_any") (param $i i32) (result i32) + (i32.add + (ref.test (ref any) (table.get $ta (local.get $i))) + (ref.test anyref (table.get $ta (local.get $i))) + ) + ) + (func (export "ref_test_eq") (param $i i32) (result i32) + (i32.add + (ref.test (ref eq) (table.get $ta (local.get $i))) + (ref.test eqref (table.get $ta (local.get $i))) + ) + ) + (func (export "ref_test_i31") (param $i i32) (result i32) + (i32.add + (ref.test (ref i31) (table.get $ta (local.get $i))) + (ref.test i31ref (table.get $ta (local.get $i))) + ) + ) + (func (export "ref_test_struct") (param $i i32) (result i32) + (i32.add + (ref.test (ref struct) (table.get $ta (local.get $i))) + (ref.test structref (table.get $ta (local.get $i))) + ) + ) + (func (export "ref_test_array") (param $i i32) (result i32) + (i32.add + (ref.test (ref array) (table.get $ta (local.get $i))) + (ref.test arrayref (table.get $ta (local.get $i))) + ) + ) + + (func (export "ref_test_null_func") (param $i i32) (result i32) + (i32.add + (ref.is_null (table.get $tf (local.get $i))) + (ref.test (ref null nofunc) (table.get $tf (local.get $i))) + ) + ) + (func (export "ref_test_func") (param $i i32) (result i32) + (i32.add + (ref.test (ref func) (table.get $tf (local.get $i))) + (ref.test funcref (table.get $tf (local.get $i))) + ) + ) + + (func (export "ref_test_null_extern") (param $i i32) (result i32) + (i32.add + (ref.is_null (table.get $te (local.get $i))) + (ref.test (ref null noextern) (table.get $te (local.get $i))) + ) + ) + (func (export "ref_test_extern") (param $i i32) (result i32) + (i32.add + (ref.test (ref extern) (table.get $te (local.get $i))) + (ref.test externref (table.get $te (local.get $i))) + ) + ) +) + +(invoke "init" (ref.extern 0)) + +(assert_return (invoke "ref_test_null_data" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "ref_test_null_data" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "ref_test_null_data" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "ref_test_null_data" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "ref_test_null_data" (i32.const 4)) (i32.const 0)) +(assert_return (invoke "ref_test_null_data" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "ref_test_null_data" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "ref_test_null_data" (i32.const 7)) (i32.const 2)) + +(assert_return (invoke "ref_test_any" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref_test_any" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref_test_any" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "ref_test_any" (i32.const 3)) (i32.const 2)) +(assert_return (invoke "ref_test_any" (i32.const 4)) (i32.const 2)) +(assert_return (invoke "ref_test_any" (i32.const 5)) (i32.const 2)) +(assert_return (invoke "ref_test_any" (i32.const 6)) (i32.const 2)) +(assert_return (invoke "ref_test_any" (i32.const 7)) (i32.const 1)) + +(assert_return (invoke "ref_test_eq" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref_test_eq" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref_test_eq" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "ref_test_eq" (i32.const 3)) (i32.const 2)) +(assert_return (invoke "ref_test_eq" (i32.const 4)) (i32.const 2)) +(assert_return (invoke "ref_test_eq" (i32.const 5)) (i32.const 2)) +(assert_return (invoke "ref_test_eq" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "ref_test_eq" (i32.const 7)) (i32.const 1)) + +(assert_return (invoke "ref_test_i31" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref_test_i31" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref_test_i31" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "ref_test_i31" (i32.const 3)) (i32.const 2)) +(assert_return (invoke "ref_test_i31" (i32.const 4)) (i32.const 0)) +(assert_return (invoke "ref_test_i31" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "ref_test_i31" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "ref_test_i31" (i32.const 7)) (i32.const 1)) + +(assert_return (invoke "ref_test_struct" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref_test_struct" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref_test_struct" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "ref_test_struct" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "ref_test_struct" (i32.const 4)) (i32.const 2)) +(assert_return (invoke "ref_test_struct" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "ref_test_struct" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "ref_test_struct" (i32.const 7)) (i32.const 1)) + +(assert_return (invoke "ref_test_array" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref_test_array" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref_test_array" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "ref_test_array" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "ref_test_array" (i32.const 4)) (i32.const 0)) +(assert_return (invoke "ref_test_array" (i32.const 5)) (i32.const 2)) +(assert_return (invoke "ref_test_array" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "ref_test_array" (i32.const 7)) (i32.const 1)) + +(assert_return (invoke "ref_test_null_func" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "ref_test_null_func" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "ref_test_null_func" (i32.const 2)) (i32.const 0)) + +(assert_return (invoke "ref_test_func" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref_test_func" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref_test_func" (i32.const 2)) (i32.const 2)) + +(assert_return (invoke "ref_test_null_extern" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "ref_test_null_extern" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "ref_test_null_extern" (i32.const 2)) (i32.const 0)) +(assert_return (invoke "ref_test_null_extern" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "ref_test_null_extern" (i32.const 4)) (i32.const 0)) +(assert_return (invoke "ref_test_null_extern" (i32.const 5)) (i32.const 2)) + +(assert_return (invoke "ref_test_extern" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref_test_extern" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref_test_extern" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "ref_test_extern" (i32.const 3)) (i32.const 2)) +(assert_return (invoke "ref_test_extern" (i32.const 4)) (i32.const 2)) +(assert_return (invoke "ref_test_extern" (i32.const 5)) (i32.const 1)) + + +;; Concrete Types + +(module + (type $t0 (sub (struct))) + (type $t1 (sub $t0 (struct (field i32)))) + (type $t1' (sub $t0 (struct (field i32)))) + (type $t2 (sub $t1 (struct (field i32 i32)))) + (type $t2' (sub $t1' (struct (field i32 i32)))) + (type $t3 (sub $t0 (struct (field i32 i32)))) + (type $t0' (sub $t0 (struct))) + (type $t4 (sub $t0' (struct (field i32 i32)))) + + (table 20 (ref null struct)) + + (func $init + (table.set (i32.const 0) (struct.new_default $t0)) + (table.set (i32.const 10) (struct.new_default $t0)) + (table.set (i32.const 1) (struct.new_default $t1)) + (table.set (i32.const 11) (struct.new_default $t1')) + (table.set (i32.const 2) (struct.new_default $t2)) + (table.set (i32.const 12) (struct.new_default $t2')) + (table.set (i32.const 3) (struct.new_default $t3)) + (table.set (i32.const 4) (struct.new_default $t4)) + ) + + (func (export "test-sub") + (call $init) + (block $l + ;; must hold + (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null struct)))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t0)))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t1)))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t2)))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t3)))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t4)))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 0))))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 1))))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 2))))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 3))))) + (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 4))))) + + (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null struct)))) + (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t0)))) + (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t1)))) + (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t2)))) + (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t3)))) + (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t4)))) + (br_if $l (i32.eqz (ref.test (ref null $t1) (table.get (i32.const 1))))) + (br_if $l (i32.eqz (ref.test (ref null $t1) (table.get (i32.const 2))))) + + (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null struct)))) + (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t0)))) + (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t1)))) + (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t2)))) + (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t3)))) + (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t4)))) + (br_if $l (i32.eqz (ref.test (ref null $t2) (table.get (i32.const 2))))) + + (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null struct)))) + (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t0)))) + (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t1)))) + (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t2)))) + (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t3)))) + (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t4)))) + (br_if $l (i32.eqz (ref.test (ref null $t3) (table.get (i32.const 3))))) + + (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null struct)))) + (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t0)))) + (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t1)))) + (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t2)))) + (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t3)))) + (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t4)))) + (br_if $l (i32.eqz (ref.test (ref null $t4) (table.get (i32.const 4))))) + + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 0))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 1))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 2))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 3))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 4))))) + + (br_if $l (i32.eqz (ref.test (ref $t1) (table.get (i32.const 1))))) + (br_if $l (i32.eqz (ref.test (ref $t1) (table.get (i32.const 2))))) + + (br_if $l (i32.eqz (ref.test (ref $t2) (table.get (i32.const 2))))) + + (br_if $l (i32.eqz (ref.test (ref $t3) (table.get (i32.const 3))))) + + (br_if $l (i32.eqz (ref.test (ref $t4) (table.get (i32.const 4))))) + + ;; must not hold + (br_if $l (ref.test (ref $t0) (ref.null struct))) + (br_if $l (ref.test (ref $t1) (ref.null struct))) + (br_if $l (ref.test (ref $t2) (ref.null struct))) + (br_if $l (ref.test (ref $t3) (ref.null struct))) + (br_if $l (ref.test (ref $t4) (ref.null struct))) + + (br_if $l (ref.test (ref $t1) (table.get (i32.const 0)))) + (br_if $l (ref.test (ref $t1) (table.get (i32.const 3)))) + (br_if $l (ref.test (ref $t1) (table.get (i32.const 4)))) + + (br_if $l (ref.test (ref $t2) (table.get (i32.const 0)))) + (br_if $l (ref.test (ref $t2) (table.get (i32.const 1)))) + (br_if $l (ref.test (ref $t2) (table.get (i32.const 3)))) + (br_if $l (ref.test (ref $t2) (table.get (i32.const 4)))) + + (br_if $l (ref.test (ref $t3) (table.get (i32.const 0)))) + (br_if $l (ref.test (ref $t3) (table.get (i32.const 1)))) + (br_if $l (ref.test (ref $t3) (table.get (i32.const 2)))) + (br_if $l (ref.test (ref $t3) (table.get (i32.const 4)))) + + (br_if $l (ref.test (ref $t4) (table.get (i32.const 0)))) + (br_if $l (ref.test (ref $t4) (table.get (i32.const 1)))) + (br_if $l (ref.test (ref $t4) (table.get (i32.const 2)))) + (br_if $l (ref.test (ref $t4) (table.get (i32.const 3)))) + + (return) + ) + (unreachable) + ) + + (func (export "test-canon") + (call $init) + (block $l + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 0))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 1))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 2))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 3))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 4))))) + + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 10))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 11))))) + (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 12))))) + + ;; Must have explicit sub relationship + ;; (br_if $l (i32.eqz (ref.test (ref $t1') (table.get (i32.const 1))))) + ;; (br_if $l (i32.eqz (ref.test (ref $t1') (table.get (i32.const 2))))) + + ;; (br_if $l (i32.eqz (ref.test (ref $t1) (table.get (i32.const 11))))) + ;; (br_if $l (i32.eqz (ref.test (ref $t1) (table.get (i32.const 12))))) + + ;; (br_if $l (i32.eqz (ref.test (ref $t2') (table.get (i32.const 2))))) + + ;; (br_if $l (i32.eqz (ref.test (ref $t2) (table.get (i32.const 12))))) + + (return) + ) + (unreachable) + ) +) + +(assert_return (invoke "test-sub")) +(assert_return (invoke "test-canon")) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/return_call_ref.wast b/tests/requirement-engineering/gc-aot/wasm-apps/return_call_ref.wast new file mode 100644 index 00000000..f79975b4 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/return_call_ref.wast @@ -0,0 +1,376 @@ +;; Test `return_call_ref` operator + +(module + ;; Auxiliary definitions + (type $proc (func)) + (type $-i32 (func (result i32))) + (type $-i64 (func (result i64))) + (type $-f32 (func (result f32))) + (type $-f64 (func (result f64))) + + (type $i32-i32 (func (param i32) (result i32))) + (type $i64-i64 (func (param i64) (result i64))) + (type $f32-f32 (func (param f32) (result f32))) + (type $f64-f64 (func (param f64) (result f64))) + + (type $f32-i32 (func (param f32 i32) (result i32))) + (type $i32-i64 (func (param i32 i64) (result i64))) + (type $f64-f32 (func (param f64 f32) (result f32))) + (type $i64-f64 (func (param i64 f64) (result f64))) + + (type $i64i64-i64 (func (param i64 i64) (result i64))) + + (func $const-i32 (result i32) (i32.const 0x132)) + (func $const-i64 (result i64) (i64.const 0x164)) + (func $const-f32 (result f32) (f32.const 0xf32)) + (func $const-f64 (result f64) (f64.const 0xf64)) + + (func $id-i32 (param i32) (result i32) (local.get 0)) + (func $id-i64 (param i64) (result i64) (local.get 0)) + (func $id-f32 (param f32) (result f32) (local.get 0)) + (func $id-f64 (param f64) (result f64) (local.get 0)) + + (func $f32-i32 (param f32 i32) (result i32) (local.get 1)) + (func $i32-i64 (param i32 i64) (result i64) (local.get 1)) + (func $f64-f32 (param f64 f32) (result f32) (local.get 1)) + (func $i64-f64 (param i64 f64) (result f64) (local.get 1)) + + (global $const-i32 (ref $-i32) (ref.func $const-i32)) + (global $const-i64 (ref $-i64) (ref.func $const-i64)) + (global $const-f32 (ref $-f32) (ref.func $const-f32)) + (global $const-f64 (ref $-f64) (ref.func $const-f64)) + + (global $id-i32 (ref $i32-i32) (ref.func $id-i32)) + (global $id-i64 (ref $i64-i64) (ref.func $id-i64)) + (global $id-f32 (ref $f32-f32) (ref.func $id-f32)) + (global $id-f64 (ref $f64-f64) (ref.func $id-f64)) + + (global $f32-i32 (ref $f32-i32) (ref.func $f32-i32)) + (global $i32-i64 (ref $i32-i64) (ref.func $i32-i64)) + (global $f64-f32 (ref $f64-f32) (ref.func $f64-f32)) + (global $i64-f64 (ref $i64-f64) (ref.func $i64-f64)) + + (elem declare func + $const-i32 $const-i64 $const-f32 $const-f64 + $id-i32 $id-i64 $id-f32 $id-f64 + $f32-i32 $i32-i64 $f64-f32 $i64-f64 + ) + + ;; Typing + + (func (export "type-i32") (result i32) + (return_call_ref $-i32 (global.get $const-i32)) + ) + (func (export "type-i64") (result i64) + (return_call_ref $-i64 (global.get $const-i64)) + ) + (func (export "type-f32") (result f32) + (return_call_ref $-f32 (global.get $const-f32)) + ) + (func (export "type-f64") (result f64) + (return_call_ref $-f64 (global.get $const-f64)) + ) + + (func (export "type-first-i32") (result i32) + (return_call_ref $i32-i32 (i32.const 32) (global.get $id-i32)) + ) + (func (export "type-first-i64") (result i64) + (return_call_ref $i64-i64 (i64.const 64) (global.get $id-i64)) + ) + (func (export "type-first-f32") (result f32) + (return_call_ref $f32-f32 (f32.const 1.32) (global.get $id-f32)) + ) + (func (export "type-first-f64") (result f64) + (return_call_ref $f64-f64 (f64.const 1.64) (global.get $id-f64)) + ) + + (func (export "type-second-i32") (result i32) + (return_call_ref $f32-i32 (f32.const 32.1) (i32.const 32) (global.get $f32-i32)) + ) + (func (export "type-second-i64") (result i64) + (return_call_ref $i32-i64 (i32.const 32) (i64.const 64) (global.get $i32-i64)) + ) + (func (export "type-second-f32") (result f32) + (return_call_ref $f64-f32 (f64.const 64) (f32.const 32) (global.get $f64-f32)) + ) + (func (export "type-second-f64") (result f64) + (return_call_ref $i64-f64 (i64.const 64) (f64.const 64.1) (global.get $i64-f64)) + ) + + ;; Null + + (func (export "null") + (return_call_ref $proc (ref.null $proc)) + ) + + ;; Recursion + + (global $fac-acc (ref $i64i64-i64) (ref.func $fac-acc)) + + (elem declare func $fac-acc) + (func $fac-acc (export "fac-acc") (param i64 i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 1)) + (else + (return_call_ref $i64i64-i64 + (i64.sub (local.get 0) (i64.const 1)) + (i64.mul (local.get 0) (local.get 1)) + (global.get $fac-acc) + ) + ) + ) + ) + + (global $count (ref $i64-i64) (ref.func $count)) + + (elem declare func $count) + (func $count (export "count") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 0)) + (else + (return_call_ref $i64-i64 + (i64.sub (local.get 0) (i64.const 1)) + (global.get $count) + ) + ) + ) + ) + + (global $even (ref $i64-i64) (ref.func $even)) + (global $odd (ref $i64-i64) (ref.func $odd)) + + (elem declare func $even) + (func $even (export "even") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 44)) + (else + (return_call_ref $i64-i64 + (i64.sub (local.get 0) (i64.const 1)) + (global.get $odd) + ) + ) + ) + ) + (elem declare func $odd) + (func $odd (export "odd") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 99)) + (else + (return_call_ref $i64-i64 + (i64.sub (local.get 0) (i64.const 1)) + (global.get $even) + ) + ) + ) + ) +) + +(assert_return (invoke "type-i32") (i32.const 0x132)) +(assert_return (invoke "type-i64") (i64.const 0x164)) +(assert_return (invoke "type-f32") (f32.const 0xf32)) +(assert_return (invoke "type-f64") (f64.const 0xf64)) + +(assert_return (invoke "type-first-i32") (i32.const 32)) +(assert_return (invoke "type-first-i64") (i64.const 64)) +(assert_return (invoke "type-first-f32") (f32.const 1.32)) +(assert_return (invoke "type-first-f64") (f64.const 1.64)) + +(assert_return (invoke "type-second-i32") (i32.const 32)) +(assert_return (invoke "type-second-i64") (i64.const 64)) +(assert_return (invoke "type-second-f32") (f32.const 32)) +(assert_return (invoke "type-second-f64") (f64.const 64.1)) + +(assert_trap (invoke "null") "null function") + +(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120)) +(assert_return + (invoke "fac-acc" (i64.const 25) (i64.const 1)) + (i64.const 7034535277573963776) +) + +(assert_return (invoke "count" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "count" (i64.const 1000)) (i64.const 0)) +(assert_return (invoke "count" (i64.const 1200)) (i64.const 0)) + +(assert_return (invoke "even" (i64.const 0)) (i64.const 44)) +(assert_return (invoke "even" (i64.const 1)) (i64.const 99)) +(assert_return (invoke "even" (i64.const 100)) (i64.const 44)) +(assert_return (invoke "even" (i64.const 77)) (i64.const 99)) +(assert_return (invoke "even" (i64.const 1200)) (i64.const 44)) +(assert_return (invoke "even" (i64.const 1201)) (i64.const 99)) +(assert_return (invoke "odd" (i64.const 0)) (i64.const 99)) +(assert_return (invoke "odd" (i64.const 1)) (i64.const 44)) +(assert_return (invoke "odd" (i64.const 200)) (i64.const 99)) +(assert_return (invoke "odd" (i64.const 77)) (i64.const 44)) +(assert_return (invoke "odd" (i64.const 1200)) (i64.const 99)) +(assert_return (invoke "odd" (i64.const 1119)) (i64.const 44)) + + +;; More typing + +(module + (type $t (func)) + (type $t1 (func (result (ref $t)))) + (type $t2 (func (result (ref null $t)))) + (type $t3 (func (result (ref func)))) + (type $t4 (func (result (ref null func)))) + (elem declare func $f11 $f22 $f33 $f44) + (func $f11 (result (ref $t)) (return_call_ref $t1 (ref.func $f11))) + (func $f21 (result (ref null $t)) (return_call_ref $t1 (ref.func $f11))) + (func $f22 (result (ref null $t)) (return_call_ref $t2 (ref.func $f22))) + (func $f31 (result (ref func)) (return_call_ref $t1 (ref.func $f11))) + (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33))) + (func $f41 (result (ref null func)) (return_call_ref $t1 (ref.func $f11))) + (func $f42 (result (ref null func)) (return_call_ref $t2 (ref.func $f22))) + (func $f43 (result (ref null func)) (return_call_ref $t3 (ref.func $f33))) + (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44))) +) + +(assert_invalid + (module + (type $t (func)) + (type $t2 (func (result (ref null $t)))) + (elem declare func $f22) + (func $f12 (result (ref $t)) (return_call_ref $t2 (ref.func $f22))) + (func $f22 (result (ref null $t)) (return_call_ref $t2 (ref.func $f22))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (type $t3 (func (result (ref func)))) + (elem declare func $f33) + (func $f13 (result (ref $t)) (return_call_ref $t3 (ref.func $f33))) + (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (type $t4 (func (result (ref null func)))) + (elem declare func $f44) + (func $f14 (result (ref $t)) (return_call_ref $t4 (ref.func $f44))) + (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (type $t3 (func (result (ref func)))) + (elem declare func $f33) + (func $f23 (result (ref null $t)) (return_call_ref $t3 (ref.func $f33))) + (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (type $t4 (func (result (ref null func)))) + (elem declare func $f44) + (func $f24 (result (ref null $t)) (return_call_ref $t4 (ref.func $f44))) + (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t4 (func (result (ref null func)))) + (elem declare func $f44) + (func $f34 (result (ref func)) (return_call_ref $t4 (ref.func $f44))) + (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44))) + ) + "type mismatch" +) + + +;; Unreachable typing. + +(module + (type $t (func (result i32))) + (func (export "unreachable") (result i32) + (unreachable) + (return_call_ref $t) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (elem declare func $f) + (type $t (func (param i32) (result i32))) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $f) + (return_call_ref $t) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (elem declare func $f) + (type $t (func (param i32) (result i32))) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i32.const 0) + (ref.func $f) + (return_call_ref $t) + (i32.const 0) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(assert_invalid + (module + (elem declare func $f) + (type $t (func (param i32) (result i32))) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i64.const 0) + (ref.func $f) + (return_call_ref $t) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (elem declare func $f) + (type $t (func (param i32) (result i32))) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $f) + (return_call_ref $t) + (i64.const 0) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (func $f (param $r externref) + (return_call_ref $t (local.get $r)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/select.wast b/tests/requirement-engineering/gc-aot/wasm-apps/select.wast new file mode 100644 index 00000000..b0b1344c --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/select.wast @@ -0,0 +1,592 @@ +(module + ;; Auxiliary + (func $dummy) + (table $tab funcref (elem $dummy)) + (memory 1) + + (func (export "select-i32") (param i32 i32 i32) (result i32) + (select (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "select-i64") (param i64 i64 i32) (result i64) + (select (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "select-f32") (param f32 f32 i32) (result f32) + (select (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "select-f64") (param f64 f64 i32) (result f64) + (select (local.get 0) (local.get 1) (local.get 2)) + ) + + (func (export "select-i32-t") (param i32 i32 i32) (result i32) + (select (result i32) (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "select-i64-t") (param i64 i64 i32) (result i64) + (select (result i64) (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "select-f32-t") (param f32 f32 i32) (result f32) + (select (result f32) (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "select-f64-t") (param f64 f64 i32) (result f64) + (select (result f64) (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "select-funcref") (param funcref funcref i32) (result funcref) + (select (result funcref) (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "select-externref") (param externref externref i32) (result externref) + (select (result externref) (local.get 0) (local.get 1) (local.get 2)) + ) + + (type $t (func)) + (func $tf) (elem declare func $tf) + (func (export "join-funcnull") (param i32) (result (ref null func)) + (select (result (ref null func)) + (ref.func $tf) + (ref.null func) + (local.get 0) + ) + ) + + ;; Check that both sides of the select are evaluated + (func (export "select-trap-left") (param $cond i32) (result i32) + (select (unreachable) (i32.const 0) (local.get $cond)) + ) + (func (export "select-trap-right") (param $cond i32) (result i32) + (select (i32.const 0) (unreachable) (local.get $cond)) + ) + + (func (export "select-unreached") + (unreachable) (select) + (unreachable) (i32.const 0) (select) + (unreachable) (i32.const 0) (i32.const 0) (select) + (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select) + (unreachable) (f32.const 0) (i32.const 0) (select) + (unreachable) + ) + + (func (export "select_unreached_result_1") (result i32) + (unreachable) (i32.add (select)) + ) + + (func (export "select_unreached_result_2") (result i64) + (unreachable) (i64.add (select (i64.const 0) (i32.const 0))) + ) + + + ;; As the argument of control constructs and instructions + + (func (export "as-select-first") (param i32) (result i32) + (select (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (param i32) (result i32) + (select (i32.const 2) (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 3)) + ) + (func (export "as-select-last") (param i32) (result i32) + (select (i32.const 2) (i32.const 3) (select (i32.const 0) (i32.const 1) (local.get 0))) + ) + + (func (export "as-loop-first") (param i32) (result i32) + (loop (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy) (call $dummy)) + ) + (func (export "as-loop-mid") (param i32) (result i32) + (loop (result i32) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy)) + ) + (func (export "as-loop-last") (param i32) (result i32) + (loop (result i32) (call $dummy) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0))) + ) + + (func (export "as-if-condition") (param i32) + (select (i32.const 2) (i32.const 3) (local.get 0)) (if (then (call $dummy))) + ) + (func (export "as-if-then") (param i32) (result i32) + (if (result i32) (i32.const 1) (then (select (i32.const 2) (i32.const 3) (local.get 0))) (else (i32.const 4))) + ) + (func (export "as-if-else") (param i32) (result i32) + (if (result i32) (i32.const 0) (then (i32.const 2)) (else (select (i32.const 2) (i32.const 3) (local.get 0)))) + ) + + (func (export "as-br_if-first") (param i32) (result i32) + (block (result i32) (br_if 0 (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 4))) + ) + (func (export "as-br_if-last") (param i32) (result i32) + (block (result i32) (br_if 0 (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0)))) + ) + + (func (export "as-br_table-first") (param i32) (result i32) + (block (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (param i32) (result i32) + (block (result i32) (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0)) (br_table 0 0)) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table $t funcref (elem $func)) + (func (export "as-call_indirect-first") (param i32) (result i32) + (block (result i32) + (call_indirect $t (type $check) + (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 1) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (param i32) (result i32) + (block (result i32) + (call_indirect $t (type $check) + (i32.const 1) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (param i32) (result i32) + (block (result i32) + (call_indirect $t (type $check) + (i32.const 1) (i32.const 4) (select (i32.const 2) (i32.const 3) (local.get 0)) + ) + ) + ) + + (func (export "as-store-first") (param i32) + (select (i32.const 0) (i32.const 4) (local.get 0)) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") (param i32) + (i32.const 8) (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.store) + ) + + (func (export "as-memory.grow-value") (param i32) (result i32) + (memory.grow (select (i32.const 1) (i32.const 2) (local.get 0))) + ) + + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "as-call-value") (param i32) (result i32) + (call $f (select (i32.const 1) (i32.const 2) (local.get 0))) + ) + (func (export "as-return-value") (param i32) (result i32) + (select (i32.const 1) (i32.const 2) (local.get 0)) (return) + ) + (func (export "as-drop-operand") (param i32) + (drop (select (i32.const 1) (i32.const 2) (local.get 0))) + ) + (func (export "as-br-value") (param i32) (result i32) + (block (result i32) (br 0 (select (i32.const 1) (i32.const 2) (local.get 0)))) + ) + (func (export "as-local.set-value") (param i32) (result i32) + (local i32) (local.set 0 (select (i32.const 1) (i32.const 2) (local.get 0))) (local.get 0) + ) + (func (export "as-local.tee-value") (param i32) (result i32) + (local.tee 0 (select (i32.const 1) (i32.const 2) (local.get 0))) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (param i32) (result i32) + (global.set $a (select (i32.const 1) (i32.const 2) (local.get 0))) + (global.get $a) + ) + (func (export "as-load-operand") (param i32) (result i32) + (i32.load (select (i32.const 0) (i32.const 4) (local.get 0))) + ) + + (func (export "as-unary-operand") (param i32) (result i32) + (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0))) + ) + (func (export "as-binary-operand") (param i32) (result i32) + (i32.mul + (select (i32.const 1) (i32.const 2) (local.get 0)) + (select (i32.const 1) (i32.const 2) (local.get 0)) + ) + ) + (func (export "as-test-operand") (param i32) (result i32) + (block (result i32) + (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0))) + ) + ) + + (func (export "as-compare-left") (param i32) (result i32) + (block (result i32) + (i32.le_s (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.const 1)) + ) + ) + (func (export "as-compare-right") (param i32) (result i32) + (block (result i32) + (i32.ne (i32.const 1) (select (i32.const 0) (i32.const 1) (local.get 0))) + ) + ) + + (func (export "as-convert-operand") (param i32) (result i32) + (block (result i32) + (i32.wrap_i64 (select (i64.const 1) (i64.const 0) (local.get 0))) + ) + ) +) + +(assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2)) +(assert_return (invoke "select-f32" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1)) +(assert_return (invoke "select-f64" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1)) + +(assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2)) +(assert_return (invoke "select-i32" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2)) +(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2)) + +(assert_return (invoke "select-f32" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan)) +(assert_return (invoke "select-f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304)) +(assert_return (invoke "select-f32" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1)) +(assert_return (invoke "select-f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1)) +(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2)) +(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2)) +(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan)) +(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304)) + +(assert_return (invoke "select-f64" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan)) +(assert_return (invoke "select-f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304)) +(assert_return (invoke "select-f64" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1)) +(assert_return (invoke "select-f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1)) +(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2)) +(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2)) +(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan)) +(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304)) + +(assert_return (invoke "select-i32-t" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2)) +(assert_return (invoke "select-f32-t" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1)) +(assert_return (invoke "select-f64-t" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1)) +(assert_return (invoke "select-funcref" (ref.null func) (ref.null func) (i32.const 1)) (ref.null func)) +(assert_return (invoke "select-externref" (ref.extern 1) (ref.extern 2) (i32.const 1)) (ref.extern 1)) + +(assert_return (invoke "select-i32-t" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2)) +(assert_return (invoke "select-i32-t" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2)) +(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2)) +(assert_return (invoke "select-externref" (ref.extern 1) (ref.extern 2) (i32.const 0)) (ref.extern 2)) +(assert_return (invoke "select-externref" (ref.extern 2) (ref.extern 1) (i32.const 0)) (ref.extern 1)) + +(assert_return (invoke "select-f32-t" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan)) +(assert_return (invoke "select-f32-t" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304)) +(assert_return (invoke "select-f32-t" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1)) +(assert_return (invoke "select-f32-t" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1)) +(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2)) +(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2)) +(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan)) +(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304)) + +(assert_return (invoke "select-f64-t" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan)) +(assert_return (invoke "select-f64-t" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304)) +(assert_return (invoke "select-f64-t" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1)) +(assert_return (invoke "select-f64-t" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1)) +(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2)) +(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2)) +(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan)) +(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304)) + +(assert_return (invoke "join-funcnull" (i32.const 1)) (ref.func)) +(assert_return (invoke "join-funcnull" (i32.const 0)) (ref.null func)) ;; we require type in expected results + +(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable") +(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable") +(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable") +(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable") + +(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 3)) + +(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-if-condition" (i32.const 0))) +(assert_return (invoke "as-if-condition" (i32.const 1))) +(assert_return (invoke "as-if-then" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-if-else" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 1)) +(assert_trap (invoke "as-call_indirect-last" (i32.const 0)) "undefined element") +(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element") + +(assert_return (invoke "as-store-first" (i32.const 0))) +(assert_return (invoke "as-store-first" (i32.const 1))) +(assert_return (invoke "as-store-last" (i32.const 0))) +(assert_return (invoke "as-store-last" (i32.const 1))) + +(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 3)) + +(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-drop-operand" (i32.const 0))) +(assert_return (invoke "as-drop-operand" (i32.const 1))) +(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-binary-operand" (i32.const 0)) (i32.const 4)) +(assert_return (invoke "as-binary-operand" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-compare-left" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-compare-right" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-convert-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-convert-operand" (i32.const 1)) (i32.const 1)) + +(assert_invalid + (module (func $arity-0-implicit (select (nop) (nop) (i32.const 1)))) + "type mismatch" +) +(assert_invalid + (module (func $arity-0 (select (result) (nop) (nop) (i32.const 1)))) + "invalid result arity" +) +(assert_invalid + (module (func $arity-2 (result i32 i32) + (select (result i32 i32) + (i32.const 0) (i32.const 0) + (i32.const 0) (i32.const 0) + (i32.const 1) + ) + )) + "invalid result arity" +) + + +(assert_invalid + (module (type $t (func)) + (func $type-ref-implicit (param $r (ref $t)) + (drop (select (local.get $r) (local.get $r) (i32.const 1))) + ) + ) + "type mismatch" +) +(assert_invalid + (module (func $type-funcref-implicit (param $r funcref) + (drop (select (local.get $r) (local.get $r) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-externref-implicit (param $r externref) + (drop (select (local.get $r) (local.get $r) (i32.const 1))) + )) + "type mismatch" +) +(module (func $type-unreachable-ref-implicit + (drop (ref.is_null (select (unreachable) (i32.const 1)))) +)) + +(assert_invalid + (module (func $type-num-vs-num + (drop (select (i32.const 1) (i64.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-num-vs-num + (drop (select (i32.const 1) (f32.const 1.0) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-num-vs-num + (drop (select (i32.const 1) (f64.const 1.0) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-num-vs-num (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop))) + "type mismatch" +) +(assert_invalid + (module (func $type-num-vs-num (select (i32.const 1) (f32.const 1.0) (i32.const 1)) (drop))) + "type mismatch" +) +(assert_invalid + (module (func $type-num-vs-num (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop))) + "type mismatch" +) +(assert_invalid + (module (func $type-num-vs-num (select (i32.const 1) (f32.const 1.0) (i32.const 1)) (drop))) + "type mismatch" +) +(assert_invalid + (module (func $type-num-vs-num (select (i32.const 1) (f64.const 1.0) (i32.const 1)) (drop))) + "type mismatch" +) + + +(assert_invalid + (module + (func $type-1st-operand-empty + (select) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-2nd-operand-empty + (i32.const 0) (select) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-3rd-operand-empty + (i32.const 0) (i32.const 0) (select) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-1st-operand-empty-in-block + (i32.const 0) (i32.const 0) (i32.const 0) + (block (select) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-2nd-operand-empty-in-block + (i32.const 0) (i32.const 0) + (block (i32.const 0) (select) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-3rd-operand-empty-in-block + (i32.const 0) + (block (i32.const 0) (i32.const 0) (select) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-1st-operand-empty-in-loop + (i32.const 0) (i32.const 0) (i32.const 0) + (loop (select) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-2nd-operand-empty-in-loop + (i32.const 0) (i32.const 0) + (loop (i32.const 0) (select) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-3rd-operand-empty-in-loop + (i32.const 0) + (loop (i32.const 0) (i32.const 0) (select) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-1st-operand-empty-in-then + (i32.const 0) (i32.const 0) (i32.const 0) + (if (then (select) (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-2nd-operand-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (i32.const 0) (select) (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-3rd-operand-empty-in-then + (i32.const 0) + (if (then (i32.const 0) (i32.const 0) (select) (drop))) + ) + ) + "type mismatch" +) + +;; Third operand must be i32 + +(assert_invalid + (module (func (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop))) + "type mismatch" +) +(assert_invalid + (module (func (select (i32.const 1) (i32.const 1) (f32.const 1)) (drop))) + "type mismatch" +) +(assert_invalid + (module (func (select (i32.const 1) (i32.const 1) (f64.const 1)) (drop))) + "type mismatch" +) + +;; Result of select has type of first two operands + +(assert_invalid + (module (func (result i32) (select (i64.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch" +) + + +;; Flat syntax + +(module + (table 1 funcref) + (func (result i32) unreachable select) + (func (result i32) unreachable select nop) + (func (result i32) unreachable select (select)) + (func (result i32) unreachable select select) + (func (result i32) unreachable select select select) + (func (result i32) unreachable select (result i32)) + (func (result i32) unreachable select (result i32) (result)) + (func (result i32) unreachable select (result i32) (result) select) + (func (result i32) unreachable select (result) (result i32) select (result i32)) + (func (result i32) unreachable select call_indirect) + (func (result i32) unreachable select call_indirect select) +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/struct.wast b/tests/requirement-engineering/gc-aot/wasm-apps/struct.wast new file mode 100644 index 00000000..7a3ce4fc --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/struct.wast @@ -0,0 +1,229 @@ +;; Type syntax + +(module + (type (struct)) + (type (struct (field))) + (type (struct (field i8))) + (type (struct (field i8 i8 i8 i8))) + (type (struct (field $x1 i32) (field $y1 i32))) + (type (struct (field i8 i16 i32 i64 f32 f64 anyref funcref (ref 0) (ref null 1)))) + (type (struct (field i32 i64 i8) (field) (field) (field (ref null i31) anyref))) + (type (struct (field $x2 i32) (field f32 f64) (field $y2 i32))) +) + + +(assert_malformed + (module quote + "(type (struct (field $x i32) (field $x i32)))" + ) + "duplicate field" +) + + +;; Binding structure + +(module + (rec + (type $s0 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1)))) + (type $s1 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1)))) + ) + + (func (param (ref $forward))) + + (type $forward (struct)) +) + +(assert_invalid + (module (type (struct (field (ref 1))))) + "unknown type" +) +(assert_invalid + (module (type (struct (field (mut (ref 1)))))) + "unknown type" +) + + +;; Field names + +(module + (type (struct (field $x i32))) + (type $t1 (struct (field i32) (field $x f32))) + (type $t2 (struct (field i32 i32) (field $x i64))) + + (func (param (ref 0)) (result i32) (struct.get 0 $x (local.get 0))) + (func (param (ref $t1)) (result f32) (struct.get 1 $x (local.get 0))) + (func (param (ref $t2)) (result i64) (struct.get $t2 $x (local.get 0))) +) + +(assert_invalid + (module + (type (struct (field $x i64))) + (type $t (struct (field $x i32))) + (func (param (ref 0)) (result i32) (struct.get 0 $x (local.get 0))) + ) + "type mismatch" +) + + +;; Basic instructions + +(module + (type $vec (struct (field f32) (field $y (mut f32)) (field $z f32))) + + (global (ref $vec) (struct.new $vec (f32.const 1) (f32.const 2) (f32.const 3))) + (global (ref $vec) (struct.new_default $vec)) + + (func (export "new") (result anyref) + (struct.new_default $vec) + ) + + (func $get_0_0 (param $v (ref $vec)) (result f32) + (struct.get 0 0 (local.get $v)) + ) + (func (export "get_0_0") (result f32) + (call $get_0_0 (struct.new_default $vec)) + ) + (func $get_vec_0 (param $v (ref $vec)) (result f32) + (struct.get $vec 0 (local.get $v)) + ) + (func (export "get_vec_0") (result f32) + (call $get_vec_0 (struct.new_default $vec)) + ) + (func $get_0_y (param $v (ref $vec)) (result f32) + (struct.get 0 $y (local.get $v)) + ) + (func (export "get_0_y") (result f32) + (call $get_0_y (struct.new_default $vec)) + ) + (func $get_vec_y (param $v (ref $vec)) (result f32) + (struct.get $vec $y (local.get $v)) + ) + (func (export "get_vec_y") (result f32) + (call $get_vec_y (struct.new_default $vec)) + ) + + (func $set_get_y (param $v (ref $vec)) (param $y f32) (result f32) + (struct.set $vec $y (local.get $v) (local.get $y)) + (struct.get $vec $y (local.get $v)) + ) + (func (export "set_get_y") (param $y f32) (result f32) + (call $set_get_y (struct.new_default $vec) (local.get $y)) + ) + + (func $set_get_1 (param $v (ref $vec)) (param $y f32) (result f32) + (struct.set $vec 1 (local.get $v) (local.get $y)) + (struct.get $vec $y (local.get $v)) + ) + (func (export "set_get_1") (param $y f32) (result f32) + (call $set_get_1 (struct.new_default $vec) (local.get $y)) + ) +) + +(assert_return (invoke "new") (ref.struct)) + +(assert_return (invoke "get_0_0") (f32.const 0)) +(assert_return (invoke "get_vec_0") (f32.const 0)) +(assert_return (invoke "get_0_y") (f32.const 0)) +(assert_return (invoke "get_vec_y") (f32.const 0)) + +(assert_return (invoke "set_get_y" (f32.const 7)) (f32.const 7)) +(assert_return (invoke "set_get_1" (f32.const 7)) (f32.const 7)) + +(assert_invalid + (module + (type $s (struct (field i64))) + (func (export "struct.set-immutable") (param $s (ref $s)) + (struct.set $s 0 (local.get $s) (i64.const 1)) + ) + ) + "field is immutable" +) + + +;; Null dereference + +(module + (type $t (struct (field i32 (mut i32)))) + (func (export "struct.get-null") + (local (ref null $t)) (drop (struct.get $t 1 (local.get 0))) + ) + (func (export "struct.set-null") + (local (ref null $t)) (struct.set $t 1 (local.get 0) (i32.const 0)) + ) +) + +(assert_trap (invoke "struct.get-null") "null structure") +(assert_trap (invoke "struct.set-null") "null structure") + +;; Packed field instructions + +(module + (type $s (struct (field i8) (field (mut i8)) (field i16) (field (mut i16)))) + + (global (export "g0") (ref $s) (struct.new $s (i32.const 0) (i32.const 1) (i32.const 2) (i32.const 3))) + (global (export "g1") (ref $s) (struct.new $s (i32.const 254) (i32.const 255) (i32.const 65534) (i32.const 65535))) + + (func (export "get_packed_g0_0") (result i32 i32) + (struct.get_s 0 0 (global.get 0)) + (struct.get_u 0 0 (global.get 0)) + ) + + (func (export "get_packed_g1_0") (result i32 i32) + (struct.get_s 0 0 (global.get 1)) + (struct.get_u 0 0 (global.get 1)) + ) + + (func (export "get_packed_g0_1") (result i32 i32) + (struct.get_s 0 1 (global.get 0)) + (struct.get_u 0 1 (global.get 0)) + ) + + (func (export "get_packed_g1_1") (result i32 i32) + (struct.get_s 0 1 (global.get 1)) + (struct.get_u 0 1 (global.get 1)) + ) + + (func (export "get_packed_g0_2") (result i32 i32) + (struct.get_s 0 2 (global.get 0)) + (struct.get_u 0 2 (global.get 0)) + ) + + (func (export "get_packed_g1_2") (result i32 i32) + (struct.get_s 0 2 (global.get 1)) + (struct.get_u 0 2 (global.get 1)) + ) + + (func (export "get_packed_g0_3") (result i32 i32) + (struct.get_s 0 3 (global.get 0)) + (struct.get_u 0 3 (global.get 0)) + ) + + (func (export "get_packed_g1_3") (result i32 i32) + (struct.get_s 0 3 (global.get 1)) + (struct.get_u 0 3 (global.get 1)) + ) + + (func (export "set_get_packed_g0_1") (param i32) (result i32 i32) + (struct.set 0 1 (global.get 0) (local.get 0)) + (struct.get_s 0 1 (global.get 0)) + (struct.get_u 0 1 (global.get 0)) + ) + + (func (export "set_get_packed_g0_3") (param i32) (result i32 i32) + (struct.set 0 3 (global.get 0) (local.get 0)) + (struct.get_s 0 3 (global.get 0)) + (struct.get_u 0 3 (global.get 0)) + ) +) + +(assert_return (invoke "get_packed_g0_0") (i32.const 0) (i32.const 0)) +(assert_return (invoke "get_packed_g1_0") (i32.const -2) (i32.const 254)) +(assert_return (invoke "get_packed_g0_1") (i32.const 1) (i32.const 1)) +(assert_return (invoke "get_packed_g1_1") (i32.const -1) (i32.const 255)) +(assert_return (invoke "get_packed_g0_2") (i32.const 2) (i32.const 2)) +(assert_return (invoke "get_packed_g1_2") (i32.const -2) (i32.const 65534)) +(assert_return (invoke "get_packed_g0_3") (i32.const 3) (i32.const 3)) +(assert_return (invoke "get_packed_g1_3") (i32.const -1) (i32.const 65535)) + +(assert_return (invoke "set_get_packed_g0_1" (i32.const 257)) (i32.const 1) (i32.const 1)) +(assert_return (invoke "set_get_packed_g0_3" (i32.const 257)) (i32.const 257) (i32.const 257)) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/table_fill.wast b/tests/requirement-engineering/gc-aot/wasm-apps/table_fill.wast new file mode 100644 index 00000000..a8e22255 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/table_fill.wast @@ -0,0 +1,157 @@ +(module + (table $t 10 externref) + + (func (export "fill") (param $i i32) (param $r externref) (param $n i32) + (table.fill $t (local.get $i) (local.get $r) (local.get $n)) + ) + + (func (export "fill-abbrev") (param $i i32) (param $r externref) (param $n i32) + (table.fill (local.get $i) (local.get $r) (local.get $n)) + ) + + (func (export "get") (param $i i32) (result externref) + (table.get $t (local.get $i)) + ) +) + +(assert_return (invoke "get" (i32.const 1)) (ref.null extern)) +(assert_return (invoke "get" (i32.const 2)) (ref.null extern)) +(assert_return (invoke "get" (i32.const 3)) (ref.null extern)) +(assert_return (invoke "get" (i32.const 4)) (ref.null extern)) +(assert_return (invoke "get" (i32.const 5)) (ref.null extern)) + +(assert_return (invoke "fill" (i32.const 2) (ref.extern 1) (i32.const 3))) +(assert_return (invoke "get" (i32.const 1)) (ref.null extern)) +(assert_return (invoke "get" (i32.const 2)) (ref.extern 1)) +(assert_return (invoke "get" (i32.const 3)) (ref.extern 1)) +(assert_return (invoke "get" (i32.const 4)) (ref.extern 1)) +(assert_return (invoke "get" (i32.const 5)) (ref.null extern)) + +(assert_return (invoke "fill" (i32.const 4) (ref.extern 2) (i32.const 2))) +(assert_return (invoke "get" (i32.const 3)) (ref.extern 1)) +(assert_return (invoke "get" (i32.const 4)) (ref.extern 2)) +(assert_return (invoke "get" (i32.const 5)) (ref.extern 2)) +(assert_return (invoke "get" (i32.const 6)) (ref.null extern)) + +(assert_return (invoke "fill" (i32.const 4) (ref.extern 3) (i32.const 0))) +(assert_return (invoke "get" (i32.const 3)) (ref.extern 1)) +(assert_return (invoke "get" (i32.const 4)) (ref.extern 2)) +(assert_return (invoke "get" (i32.const 5)) (ref.extern 2)) + +(assert_return (invoke "fill" (i32.const 8) (ref.extern 4) (i32.const 2))) +(assert_return (invoke "get" (i32.const 7)) (ref.null extern)) +(assert_return (invoke "get" (i32.const 8)) (ref.extern 4)) +(assert_return (invoke "get" (i32.const 9)) (ref.extern 4)) + +(assert_return (invoke "fill-abbrev" (i32.const 9) (ref.null extern) (i32.const 1))) +(assert_return (invoke "get" (i32.const 8)) (ref.extern 4)) +(assert_return (invoke "get" (i32.const 9)) (ref.null extern)) + +(assert_return (invoke "fill" (i32.const 10) (ref.extern 5) (i32.const 0))) +(assert_return (invoke "get" (i32.const 9)) (ref.null extern)) + +(assert_trap + (invoke "fill" (i32.const 8) (ref.extern 6) (i32.const 3)) + "out of bounds table access" +) +(assert_return (invoke "get" (i32.const 7)) (ref.null extern)) +(assert_return (invoke "get" (i32.const 8)) (ref.extern 4)) +(assert_return (invoke "get" (i32.const 9)) (ref.null extern)) + +(assert_trap + (invoke "fill" (i32.const 11) (ref.null extern) (i32.const 0)) + "out of bounds table access" +) + +(assert_trap + (invoke "fill" (i32.const 11) (ref.null extern) (i32.const 10)) + "out of bounds table access" +) + + +;; Type errors + +(assert_invalid + (module + (table $t 10 externref) + (func $type-index-value-length-empty-vs-i32-i32 + (table.fill $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 externref) + (func $type-index-empty-vs-i32 + (table.fill $t (ref.null extern) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 externref) + (func $type-value-empty-vs + (table.fill $t (i32.const 1) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 externref) + (func $type-length-empty-vs-i32 + (table.fill $t (i32.const 1) (ref.null extern)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 externref) + (func $type-index-f32-vs-i32 + (table.fill $t (f32.const 1) (ref.null extern) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 funcref) + (func $type-value-vs-funcref (param $r externref) + (table.fill $t (i32.const 1) (local.get $r) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 externref) + (func $type-length-f32-vs-i32 + (table.fill $t (i32.const 1) (ref.null extern) (f32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t1 1 externref) + (table $t2 1 funcref) + (func $type-value-externref-vs-funcref-multi (param $r externref) + (table.fill $t2 (i32.const 0) (local.get $r) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 1 externref) + (func $type-result-empty-vs-num (result i32) + (table.fill $t (i32.const 0) (ref.null extern) (i32.const 1)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/table_get.wast b/tests/requirement-engineering/gc-aot/wasm-apps/table_get.wast new file mode 100644 index 00000000..0dedb19f --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/table_get.wast @@ -0,0 +1,88 @@ +(module + (table $t2 2 externref) + (table $t3 3 funcref) + (elem (table $t3) (i32.const 1) func $dummy) + (func $dummy) + + (func (export "init") (param $r externref) + (table.set $t2 (i32.const 1) (local.get $r)) + (table.set $t3 (i32.const 2) (table.get $t3 (i32.const 1))) + ) + + (func (export "get-externref") (param $i i32) (result externref) + (table.get (local.get $i)) + ) + (func $f3 (export "get-funcref") (param $i i32) (result funcref) + (table.get $t3 (local.get $i)) + ) + + (func (export "is_null-funcref") (param $i i32) (result i32) + (ref.is_null (call $f3 (local.get $i))) + ) +) + +(invoke "init" (ref.extern 1)) + +(assert_return (invoke "get-externref" (i32.const 0)) (ref.null extern)) +(assert_return (invoke "get-externref" (i32.const 1)) (ref.extern 1)) + +(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func)) +(assert_return (invoke "is_null-funcref" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "is_null-funcref" (i32.const 2)) (i32.const 0)) + +(assert_trap (invoke "get-externref" (i32.const 2)) "out of bounds table access") +(assert_trap (invoke "get-funcref" (i32.const 3)) "out of bounds table access") +(assert_trap (invoke "get-externref" (i32.const -1)) "out of bounds table access") +(assert_trap (invoke "get-funcref" (i32.const -1)) "out of bounds table access") + + +;; Type errors + +(assert_invalid + (module + (table $t 10 externref) + (func $type-index-empty-vs-i32 (result externref) + (table.get $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 externref) + (func $type-index-f32-vs-i32 (result externref) + (table.get $t (f32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 10 externref) + (func $type-result-externref-vs-empty + (table.get $t (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 externref) + (func $type-result-externref-vs-funcref (result funcref) + (table.get $t (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t1 1 funcref) + (table $t2 1 externref) + (func $type-result-externref-vs-funcref-multi (result funcref) + (table.get $t2 (i32.const 0)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/table_grow.wast b/tests/requirement-engineering/gc-aot/wasm-apps/table_grow.wast new file mode 100644 index 00000000..9a931a7f --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/table_grow.wast @@ -0,0 +1,176 @@ +(module + (table $t 0 externref) + + (func (export "get") (param $i i32) (result externref) (table.get $t (local.get $i))) + (func (export "set") (param $i i32) (param $r externref) (table.set $t (local.get $i) (local.get $r))) + + (func (export "grow") (param $sz i32) (param $init externref) (result i32) + (table.grow $t (local.get $init) (local.get $sz)) + ) + (func (export "grow-abbrev") (param $sz i32) (param $init externref) (result i32) + (table.grow (local.get $init) (local.get $sz)) + ) + (func (export "size") (result i32) (table.size $t)) +) + +(assert_return (invoke "size") (i32.const 0)) +(assert_trap (invoke "set" (i32.const 0) (ref.extern 2)) "out of bounds table access") +(assert_trap (invoke "get" (i32.const 0)) "out of bounds table access") + +(assert_return (invoke "grow" (i32.const 1) (ref.null extern)) (i32.const 0)) +(assert_return (invoke "size") (i32.const 1)) +(assert_return (invoke "get" (i32.const 0)) (ref.null extern)) +(assert_return (invoke "set" (i32.const 0) (ref.extern 2))) +(assert_return (invoke "get" (i32.const 0)) (ref.extern 2)) +(assert_trap (invoke "set" (i32.const 1) (ref.extern 2)) "out of bounds table access") +(assert_trap (invoke "get" (i32.const 1)) "out of bounds table access") + +(assert_return (invoke "grow-abbrev" (i32.const 4) (ref.extern 3)) (i32.const 1)) +(assert_return (invoke "size") (i32.const 5)) +(assert_return (invoke "get" (i32.const 0)) (ref.extern 2)) +(assert_return (invoke "set" (i32.const 0) (ref.extern 2))) +(assert_return (invoke "get" (i32.const 0)) (ref.extern 2)) +(assert_return (invoke "get" (i32.const 1)) (ref.extern 3)) +(assert_return (invoke "get" (i32.const 4)) (ref.extern 3)) +(assert_return (invoke "set" (i32.const 4) (ref.extern 4))) +(assert_return (invoke "get" (i32.const 4)) (ref.extern 4)) +(assert_trap (invoke "set" (i32.const 5) (ref.extern 2)) "out of bounds table access") +(assert_trap (invoke "get" (i32.const 5)) "out of bounds table access") + + +;; Reject growing to size outside i32 value range +(module + (table $t 0x10 funcref) + (elem declare func $f) + (func $f (export "grow") (result i32) + (table.grow $t (ref.func $f) (i32.const 0xffff_fff0)) + ) +) + +(assert_return (invoke "grow") (i32.const -1)) + + +(module + (table $t 0 externref) + (func (export "grow") (param i32) (result i32) + (table.grow $t (ref.null extern) (local.get 0)) + ) +) + +(assert_return (invoke "grow" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 800)) (i32.const 3)) + + +(module + (table $t 0 10 externref) + (func (export "grow") (param i32) (result i32) + (table.grow $t (ref.null extern) (local.get 0)) + ) +) + +(assert_return (invoke "grow" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "grow" (i32.const 6)) (i32.const 4)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 10)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1)) + + +(module + (table $t 10 funcref) + (func (export "grow") (param i32) (result i32) + (table.grow $t (ref.null func) (local.get 0)) + ) + (elem declare func 1) + (func (export "check-table-null") (param i32 i32) (result funcref) + (local funcref) + (local.set 2 (ref.func 1)) + (block + (loop + (local.set 2 (table.get $t (local.get 0))) + (br_if 1 (i32.eqz (ref.is_null (local.get 2)))) + (br_if 1 (i32.ge_u (local.get 0) (local.get 1))) + (local.set 0 (i32.add (local.get 0) (i32.const 1))) + (br_if 0 (i32.le_u (local.get 0) (local.get 1))) + ) + ) + (local.get 2) + ) +) + +(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 9)) (ref.null func)) +(assert_return (invoke "grow" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 19)) (ref.null func)) + + +;; Type errors + +(assert_invalid + (module + (table $t 0 externref) + (func $type-init-size-empty-vs-i32-externref (result i32) + (table.grow $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 externref) + (func $type-size-empty-vs-i32 (result i32) + (table.grow $t (ref.null extern)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 externref) + (func $type-init-empty-vs-externref (result i32) + (table.grow $t (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 externref) + (func $type-size-f32-vs-i32 (result i32) + (table.grow $t (ref.null extern) (f32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 funcref) + (func $type-init-externref-vs-funcref (param $r externref) (result i32) + (table.grow $t (local.get $r) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 1 externref) + (func $type-result-i32-vs-empty + (table.grow $t (ref.null extern) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 1 externref) + (func $type-result-i32-vs-f32 (result f32) + (table.grow $t (ref.null extern) (i32.const 0)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/table_init.wast b/tests/requirement-engineering/gc-aot/wasm-apps/table_init.wast new file mode 100644 index 00000000..bdab6a01 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/table_init.wast @@ -0,0 +1,2149 @@ +;; +;; Generated by ../meta/generate_table_init.js +;; DO NOT EDIT THIS FILE. CHANGE THE SOURCE AND REGENERATE. +;; + +(module + (func (export "ef0") (result i32) (i32.const 0)) + (func (export "ef1") (result i32) (i32.const 1)) + (func (export "ef2") (result i32) (i32.const 2)) + (func (export "ef3") (result i32) (i32.const 3)) + (func (export "ef4") (result i32) (i32.const 4)) +) +(register "a") + +(module + (type (func (result i32))) ;; type #0 + ;; aot mode does not support module linking + (func (result i32) (i32.const 0)) ;; index 0 + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) ;; index 4 + (table $t0 30 30 funcref) + (table $t1 30 30 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 5)) ;; index 5 + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) ;; index 9 + (func (export "test") + (table.init $t0 1 (i32.const 7) (i32.const 0) (i32.const 4))) + (func (export "check") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check" (i32.const 6)) "uninitialized element") +(assert_return (invoke "check" (i32.const 7)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 8)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 9)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 10)) (i32.const 8)) +(assert_trap (invoke "check" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + ;; aot mode does not support module linking + (func (result i32) (i32.const 0)) ;; index 0 + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) ;; index 4 + (table $t0 30 30 funcref) + (table $t1 30 30 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 5)) ;; index 5 + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) ;; index 9 + (func (export "test") + (table.init $t0 3 (i32.const 15) (i32.const 1) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 15)) (i32.const 9)) +(assert_return (invoke "check" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 17)) (i32.const 7)) +(assert_trap (invoke "check" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + ;; aot mode does not support module linking + (func (result i32) (i32.const 0)) ;; index 0 + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) ;; index 4 + (table $t0 30 30 funcref) + (table $t1 30 30 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 5)) ;; index 5 + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) ;; index 9 + (func (export "test") + (table.init $t0 1 (i32.const 7) (i32.const 0) (i32.const 4)) + (elem.drop 1) + (table.init $t0 3 (i32.const 15) (i32.const 1) (i32.const 3)) + (elem.drop 3) + (table.copy $t0 0 (i32.const 20) (i32.const 15) (i32.const 5)) + (table.copy $t0 0 (i32.const 21) (i32.const 29) (i32.const 1)) + (table.copy $t0 0 (i32.const 24) (i32.const 10) (i32.const 1)) + (table.copy $t0 0 (i32.const 13) (i32.const 11) (i32.const 4)) + (table.copy $t0 0 (i32.const 19) (i32.const 20) (i32.const 5))) + (func (export "check") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check" (i32.const 6)) "uninitialized element") +(assert_return (invoke "check" (i32.const 7)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 8)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 9)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 10)) (i32.const 8)) +(assert_trap (invoke "check" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check" (i32.const 12)) (i32.const 7)) +(assert_trap (invoke "check" (i32.const 13)) "uninitialized element") +(assert_return (invoke "check" (i32.const 14)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 15)) (i32.const 5)) +(assert_return (invoke "check" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 17)) (i32.const 7)) +(assert_trap (invoke "check" (i32.const 18)) "uninitialized element") +(assert_return (invoke "check" (i32.const 19)) (i32.const 9)) +(assert_trap (invoke "check" (i32.const 20)) "uninitialized element") +(assert_return (invoke "check" (i32.const 21)) (i32.const 7)) +(assert_trap (invoke "check" (i32.const 22)) "uninitialized element") +(assert_return (invoke "check" (i32.const 23)) (i32.const 8)) +(assert_return (invoke "check" (i32.const 24)) (i32.const 8)) +(assert_trap (invoke "check" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + ;; aot mode does not support module linking + (func (result i32) (i32.const 0)) ;; index 0 + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) ;; index 4 + (table $t0 30 30 funcref) + (table $t1 30 30 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 5)) ;; index 5 + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) ;; index 9 + (func (export "test") + (table.init $t1 1 (i32.const 7) (i32.const 0) (i32.const 4))) + (func (export "check") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check" (i32.const 6)) "uninitialized element") +(assert_return (invoke "check" (i32.const 7)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 8)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 9)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 10)) (i32.const 8)) +(assert_trap (invoke "check" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + ;; aot mode does not support module linking + (func (result i32) (i32.const 0)) ;; index 0 + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) ;; index 4 + (table $t0 30 30 funcref) + (table $t1 30 30 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 5)) ;; index 5 + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) ;; index 9 + (func (export "test") + (table.init $t1 3 (i32.const 15) (i32.const 1) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 15)) (i32.const 9)) +(assert_return (invoke "check" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 17)) (i32.const 7)) +(assert_trap (invoke "check" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + ;; aot mode does not support module linking + (func (result i32) (i32.const 0)) ;; index 0 + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) ;; index 4 + (table $t0 30 30 funcref) + (table $t1 30 30 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 5)) ;; index 5 + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) ;; index 9 + (func (export "test") + (table.init $t1 1 (i32.const 7) (i32.const 0) (i32.const 4)) + (elem.drop 1) + (table.init $t1 3 (i32.const 15) (i32.const 1) (i32.const 3)) + (elem.drop 3) + (table.copy $t1 1 (i32.const 20) (i32.const 15) (i32.const 5)) + (table.copy $t1 1 (i32.const 21) (i32.const 29) (i32.const 1)) + (table.copy $t1 1 (i32.const 24) (i32.const 10) (i32.const 1)) + (table.copy $t1 1 (i32.const 13) (i32.const 11) (i32.const 4)) + (table.copy $t1 1 (i32.const 19) (i32.const 20) (i32.const 5))) + (func (export "check") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check" (i32.const 6)) "uninitialized element") +(assert_return (invoke "check" (i32.const 7)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 8)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 9)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 10)) (i32.const 8)) +(assert_trap (invoke "check" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check" (i32.const 12)) (i32.const 7)) +(assert_trap (invoke "check" (i32.const 13)) "uninitialized element") +(assert_return (invoke "check" (i32.const 14)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 15)) (i32.const 5)) +(assert_return (invoke "check" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 17)) (i32.const 7)) +(assert_trap (invoke "check" (i32.const 18)) "uninitialized element") +(assert_return (invoke "check" (i32.const 19)) (i32.const 9)) +(assert_trap (invoke "check" (i32.const 20)) "uninitialized element") +(assert_return (invoke "check" (i32.const 21)) (i32.const 7)) +(assert_trap (invoke "check" (i32.const 22)) "uninitialized element") +(assert_return (invoke "check" (i32.const 23)) (i32.const 8)) +(assert_return (invoke "check" (i32.const 24)) (i32.const 8)) +(assert_trap (invoke "check" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 29)) "uninitialized element") +(assert_invalid + (module + (func (export "test") + (elem.drop 0))) + "unknown elem segment 0") + +(assert_invalid + (module + (func (export "test") + (table.init 0 (i32.const 12) (i32.const 1) (i32.const 1)))) + "unknown table 0") + +(assert_invalid + (module + (elem funcref (ref.func 0)) + (func (result i32) (i32.const 0)) + (func (export "test") + (elem.drop 4))) + "unknown elem segment 4") + +(assert_invalid + (module + (elem funcref (ref.func 0)) + (func (result i32) (i32.const 0)) + (func (export "test") + (table.init 4 (i32.const 12) (i32.const 1) (i32.const 1)))) + "unknown table 0") + + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (elem.drop 2) + )) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init 2 (i32.const 12) (i32.const 1) (i32.const 1)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1)) + (table.init 1 (i32.const 21) (i32.const 1) (i32.const 1)))) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (elem.drop 1) + (elem.drop 1))) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (elem.drop 1) + (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1)))) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init 1 (i32.const 12) (i32.const 0) (i32.const 5)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init 1 (i32.const 12) (i32.const 2) (i32.const 3)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t0 1 (i32.const 28) (i32.const 1) (i32.const 3)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t0 1 (i32.const 12) (i32.const 4) (i32.const 0)) + )) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t0 1 (i32.const 12) (i32.const 5) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t0 1 (i32.const 30) (i32.const 2) (i32.const 0)) + )) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t0 1 (i32.const 31) (i32.const 2) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t0 1 (i32.const 30) (i32.const 4) (i32.const 0)) + )) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t0) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t0) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t0 1 (i32.const 31) (i32.const 5) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t1 1 (i32.const 26) (i32.const 1) (i32.const 3)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t1 1 (i32.const 12) (i32.const 4) (i32.const 0)) + )) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t1 1 (i32.const 12) (i32.const 5) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t1 1 (i32.const 28) (i32.const 2) (i32.const 0)) + )) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t1 1 (i32.const 29) (i32.const 2) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t1 1 (i32.const 28) (i32.const 4) (i32.const 0)) + )) +(invoke "test") + +(module + (table $t0 30 30 funcref) + (table $t1 28 28 funcref) + (elem (table $t1) (i32.const 2) func 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (table $t1) (i32.const 12) func 7 5 2 3 6) + (elem funcref + (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6)) + (func (result i32) (i32.const 0)) + (func (result i32) (i32.const 1)) + (func (result i32) (i32.const 2)) + (func (result i32) (i32.const 3)) + (func (result i32) (i32.const 4)) + (func (result i32) (i32.const 5)) + (func (result i32) (i32.const 6)) + (func (result i32) (i32.const 7)) + (func (result i32) (i32.const 8)) + (func (result i32) (i32.const 9)) + (func (export "test") + (table.init $t1 1 (i32.const 29) (i32.const 5) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds table access") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i32.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f32.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (i64.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (table 10 funcref) + (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0)) + (func $f0) + (func (export "test") + (table.init 0 (f64.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem funcref + (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3) + (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7) + (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11) + (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15)) + (func $f0 (export "f0") (result i32) (i32.const 0)) + (func $f1 (export "f1") (result i32) (i32.const 1)) + (func $f2 (export "f2") (result i32) (i32.const 2)) + (func $f3 (export "f3") (result i32) (i32.const 3)) + (func $f4 (export "f4") (result i32) (i32.const 4)) + (func $f5 (export "f5") (result i32) (i32.const 5)) + (func $f6 (export "f6") (result i32) (i32.const 6)) + (func $f7 (export "f7") (result i32) (i32.const 7)) + (func $f8 (export "f8") (result i32) (i32.const 8)) + (func $f9 (export "f9") (result i32) (i32.const 9)) + (func $f10 (export "f10") (result i32) (i32.const 10)) + (func $f11 (export "f11") (result i32) (i32.const 11)) + (func $f12 (export "f12") (result i32) (i32.const 12)) + (func $f13 (export "f13") (result i32) (i32.const 13)) + (func $f14 (export "f14") (result i32) (i32.const 14)) + (func $f15 (export "f15") (result i32) (i32.const 15)) + (func (export "test") (param $n i32) (result i32) + (call_indirect (type 0) (local.get $n))) + (func (export "run") (param $offs i32) (param $len i32) + (table.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) +(assert_trap (invoke "run" (i32.const 24) (i32.const 16)) "out of bounds table access") +(assert_trap (invoke "test" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 2)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 4)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 5)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 11)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 12)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 30)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 31)) "uninitialized element") + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem funcref + (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3) + (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7) + (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11) + (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15)) + (func $f0 (export "f0") (result i32) (i32.const 0)) + (func $f1 (export "f1") (result i32) (i32.const 1)) + (func $f2 (export "f2") (result i32) (i32.const 2)) + (func $f3 (export "f3") (result i32) (i32.const 3)) + (func $f4 (export "f4") (result i32) (i32.const 4)) + (func $f5 (export "f5") (result i32) (i32.const 5)) + (func $f6 (export "f6") (result i32) (i32.const 6)) + (func $f7 (export "f7") (result i32) (i32.const 7)) + (func $f8 (export "f8") (result i32) (i32.const 8)) + (func $f9 (export "f9") (result i32) (i32.const 9)) + (func $f10 (export "f10") (result i32) (i32.const 10)) + (func $f11 (export "f11") (result i32) (i32.const 11)) + (func $f12 (export "f12") (result i32) (i32.const 12)) + (func $f13 (export "f13") (result i32) (i32.const 13)) + (func $f14 (export "f14") (result i32) (i32.const 14)) + (func $f15 (export "f15") (result i32) (i32.const 15)) + (func (export "test") (param $n i32) (result i32) + (call_indirect (type 0) (local.get $n))) + (func (export "run") (param $offs i32) (param $len i32) + (table.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) +(assert_trap (invoke "run" (i32.const 25) (i32.const 16)) "out of bounds table access") +(assert_trap (invoke "test" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 2)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 4)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 5)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 11)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 12)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 30)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 31)) "uninitialized element") + +(module + (type (func (result i32))) + (table 160 320 funcref) + (elem funcref + (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3) + (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7) + (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11) + (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15)) + (func $f0 (export "f0") (result i32) (i32.const 0)) + (func $f1 (export "f1") (result i32) (i32.const 1)) + (func $f2 (export "f2") (result i32) (i32.const 2)) + (func $f3 (export "f3") (result i32) (i32.const 3)) + (func $f4 (export "f4") (result i32) (i32.const 4)) + (func $f5 (export "f5") (result i32) (i32.const 5)) + (func $f6 (export "f6") (result i32) (i32.const 6)) + (func $f7 (export "f7") (result i32) (i32.const 7)) + (func $f8 (export "f8") (result i32) (i32.const 8)) + (func $f9 (export "f9") (result i32) (i32.const 9)) + (func $f10 (export "f10") (result i32) (i32.const 10)) + (func $f11 (export "f11") (result i32) (i32.const 11)) + (func $f12 (export "f12") (result i32) (i32.const 12)) + (func $f13 (export "f13") (result i32) (i32.const 13)) + (func $f14 (export "f14") (result i32) (i32.const 14)) + (func $f15 (export "f15") (result i32) (i32.const 15)) + (func (export "test") (param $n i32) (result i32) + (call_indirect (type 0) (local.get $n))) + (func (export "run") (param $offs i32) (param $len i32) + (table.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) +(assert_trap (invoke "run" (i32.const 96) (i32.const 32)) "out of bounds table access") +(assert_trap (invoke "test" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 2)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 4)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 5)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 11)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 12)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 30)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 31)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 32)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 33)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 34)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 35)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 36)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 37)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 38)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 39)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 40)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 41)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 42)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 43)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 44)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 45)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 46)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 47)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 48)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 49)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 50)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 51)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 52)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 53)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 54)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 55)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 56)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 57)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 58)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 59)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 60)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 61)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 62)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 63)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 64)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 65)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 66)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 67)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 68)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 69)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 70)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 71)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 72)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 73)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 74)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 75)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 76)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 77)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 78)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 79)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 80)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 81)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 82)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 83)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 84)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 85)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 86)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 87)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 88)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 89)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 90)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 91)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 92)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 93)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 94)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 95)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 96)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 97)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 98)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 99)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 100)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 101)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 102)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 103)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 104)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 105)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 106)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 107)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 108)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 109)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 110)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 111)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 112)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 113)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 114)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 115)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 116)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 117)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 118)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 119)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 120)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 121)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 122)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 123)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 124)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 125)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 126)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 127)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 128)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 129)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 130)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 131)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 132)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 133)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 134)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 135)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 136)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 137)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 138)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 139)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 140)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 141)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 142)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 143)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 144)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 145)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 146)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 147)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 148)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 149)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 150)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 151)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 152)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 153)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 154)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 155)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 156)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 157)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 158)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 159)) "uninitialized element") + +(module + (type (func (result i32))) + (table 160 320 funcref) + (elem funcref + (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3) + (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7) + (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11) + (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15)) + (func $f0 (export "f0") (result i32) (i32.const 0)) + (func $f1 (export "f1") (result i32) (i32.const 1)) + (func $f2 (export "f2") (result i32) (i32.const 2)) + (func $f3 (export "f3") (result i32) (i32.const 3)) + (func $f4 (export "f4") (result i32) (i32.const 4)) + (func $f5 (export "f5") (result i32) (i32.const 5)) + (func $f6 (export "f6") (result i32) (i32.const 6)) + (func $f7 (export "f7") (result i32) (i32.const 7)) + (func $f8 (export "f8") (result i32) (i32.const 8)) + (func $f9 (export "f9") (result i32) (i32.const 9)) + (func $f10 (export "f10") (result i32) (i32.const 10)) + (func $f11 (export "f11") (result i32) (i32.const 11)) + (func $f12 (export "f12") (result i32) (i32.const 12)) + (func $f13 (export "f13") (result i32) (i32.const 13)) + (func $f14 (export "f14") (result i32) (i32.const 14)) + (func $f15 (export "f15") (result i32) (i32.const 15)) + (func (export "test") (param $n i32) (result i32) + (call_indirect (type 0) (local.get $n))) + (func (export "run") (param $offs i32) (param $len i32) + (table.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) +(assert_trap (invoke "run" (i32.const 97) (i32.const 31)) "out of bounds table access") +(assert_trap (invoke "test" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 2)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 4)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 5)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 11)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 12)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 30)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 31)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 32)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 33)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 34)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 35)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 36)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 37)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 38)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 39)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 40)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 41)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 42)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 43)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 44)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 45)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 46)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 47)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 48)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 49)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 50)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 51)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 52)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 53)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 54)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 55)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 56)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 57)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 58)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 59)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 60)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 61)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 62)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 63)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 64)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 65)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 66)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 67)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 68)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 69)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 70)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 71)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 72)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 73)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 74)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 75)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 76)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 77)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 78)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 79)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 80)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 81)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 82)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 83)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 84)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 85)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 86)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 87)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 88)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 89)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 90)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 91)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 92)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 93)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 94)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 95)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 96)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 97)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 98)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 99)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 100)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 101)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 102)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 103)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 104)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 105)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 106)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 107)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 108)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 109)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 110)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 111)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 112)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 113)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 114)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 115)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 116)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 117)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 118)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 119)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 120)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 121)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 122)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 123)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 124)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 125)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 126)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 127)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 128)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 129)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 130)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 131)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 132)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 133)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 134)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 135)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 136)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 137)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 138)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 139)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 140)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 141)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 142)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 143)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 144)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 145)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 146)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 147)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 148)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 149)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 150)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 151)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 152)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 153)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 154)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 155)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 156)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 157)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 158)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 159)) "uninitialized element") + +(module + (type (func (result i32))) + (table 64 64 funcref) + (elem funcref + (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3) + (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7) + (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11) + (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15)) + (func $f0 (export "f0") (result i32) (i32.const 0)) + (func $f1 (export "f1") (result i32) (i32.const 1)) + (func $f2 (export "f2") (result i32) (i32.const 2)) + (func $f3 (export "f3") (result i32) (i32.const 3)) + (func $f4 (export "f4") (result i32) (i32.const 4)) + (func $f5 (export "f5") (result i32) (i32.const 5)) + (func $f6 (export "f6") (result i32) (i32.const 6)) + (func $f7 (export "f7") (result i32) (i32.const 7)) + (func $f8 (export "f8") (result i32) (i32.const 8)) + (func $f9 (export "f9") (result i32) (i32.const 9)) + (func $f10 (export "f10") (result i32) (i32.const 10)) + (func $f11 (export "f11") (result i32) (i32.const 11)) + (func $f12 (export "f12") (result i32) (i32.const 12)) + (func $f13 (export "f13") (result i32) (i32.const 13)) + (func $f14 (export "f14") (result i32) (i32.const 14)) + (func $f15 (export "f15") (result i32) (i32.const 15)) + (func (export "test") (param $n i32) (result i32) + (call_indirect (type 0) (local.get $n))) + (func (export "run") (param $offs i32) (param $len i32) + (table.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) +(assert_trap (invoke "run" (i32.const 48) (i32.const 4294967280)) "out of bounds table access") +(assert_trap (invoke "test" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 2)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 4)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 5)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 11)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 12)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 30)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 31)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 32)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 33)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 34)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 35)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 36)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 37)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 38)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 39)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 40)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 41)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 42)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 43)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 44)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 45)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 46)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 47)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 48)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 49)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 50)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 51)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 52)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 53)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 54)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 55)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 56)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 57)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 58)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 59)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 60)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 61)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 62)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 63)) "uninitialized element") + +(module + (type (func (result i32))) + (table 16 16 funcref) + (elem funcref + (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3) + (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7) + (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11) + (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15)) + (func $f0 (export "f0") (result i32) (i32.const 0)) + (func $f1 (export "f1") (result i32) (i32.const 1)) + (func $f2 (export "f2") (result i32) (i32.const 2)) + (func $f3 (export "f3") (result i32) (i32.const 3)) + (func $f4 (export "f4") (result i32) (i32.const 4)) + (func $f5 (export "f5") (result i32) (i32.const 5)) + (func $f6 (export "f6") (result i32) (i32.const 6)) + (func $f7 (export "f7") (result i32) (i32.const 7)) + (func $f8 (export "f8") (result i32) (i32.const 8)) + (func $f9 (export "f9") (result i32) (i32.const 9)) + (func $f10 (export "f10") (result i32) (i32.const 10)) + (func $f11 (export "f11") (result i32) (i32.const 11)) + (func $f12 (export "f12") (result i32) (i32.const 12)) + (func $f13 (export "f13") (result i32) (i32.const 13)) + (func $f14 (export "f14") (result i32) (i32.const 14)) + (func $f15 (export "f15") (result i32) (i32.const 15)) + (func (export "test") (param $n i32) (result i32) + (call_indirect (type 0) (local.get $n))) + (func (export "run") (param $offs i32) (param $len i32) + (table.init 0 (local.get $offs) (i32.const 8) (local.get $len)))) +(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292)) "out of bounds table access") +(assert_trap (invoke "test" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 2)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 4)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 5)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 11)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 12)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "test" (i32.const 15)) "uninitialized element") + +(module + (table 1 funcref) + ;; 65 elem segments. 64 is the smallest positive number that is encoded + ;; differently as a signed LEB. + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) (elem funcref) (elem funcref) (elem funcref) + (elem funcref) + (func (table.init 64 (i32.const 0) (i32.const 0) (i32.const 0)))) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/table_set.wast b/tests/requirement-engineering/gc-aot/wasm-apps/table_set.wast new file mode 100644 index 00000000..3362f956 --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/table_set.wast @@ -0,0 +1,119 @@ +(module + (table $t2 1 externref) + (table $t3 2 funcref) + (elem (table $t3) (i32.const 1) func $dummy) + (func $dummy) + + (func (export "get-externref") (param $i i32) (result externref) + (table.get $t2 (local.get $i)) + ) + (func $f3 (export "get-funcref") (param $i i32) (result funcref) + (table.get $t3 (local.get $i)) + ) + + (func (export "set-externref") (param $i i32) (param $r externref) + (table.set (local.get $i) (local.get $r)) + ) + (func (export "set-funcref") (param $i i32) (param $r funcref) + (table.set $t3 (local.get $i) (local.get $r)) + ) + (func (export "set-funcref-from") (param $i i32) (param $j i32) + (table.set $t3 (local.get $i) (table.get $t3 (local.get $j))) + ) + + (func (export "is_null-funcref") (param $i i32) (result i32) + (ref.is_null (call $f3 (local.get $i))) + ) +) + +(assert_return (invoke "get-externref" (i32.const 0)) (ref.null extern)) +(assert_return (invoke "set-externref" (i32.const 0) (ref.extern 1))) +(assert_return (invoke "get-externref" (i32.const 0)) (ref.extern 1)) +(assert_return (invoke "set-externref" (i32.const 0) (ref.null extern))) +(assert_return (invoke "get-externref" (i32.const 0)) (ref.null extern)) + +(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func)) +(assert_return (invoke "set-funcref-from" (i32.const 0) (i32.const 1))) +(assert_return (invoke "is_null-funcref" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "set-funcref" (i32.const 0) (ref.null func))) +(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func)) + +(assert_trap (invoke "set-externref" (i32.const 2) (ref.null extern)) "out of bounds table access") +(assert_trap (invoke "set-funcref" (i32.const 3) (ref.null func)) "out of bounds table access") +(assert_trap (invoke "set-externref" (i32.const -1) (ref.null extern)) "out of bounds table access") +(assert_trap (invoke "set-funcref" (i32.const -1) (ref.null func)) "out of bounds table access") + +(assert_trap (invoke "set-externref" (i32.const 2) (ref.extern 0)) "out of bounds table access") +(assert_trap (invoke "set-funcref-from" (i32.const 3) (i32.const 1)) "out of bounds table access") +(assert_trap (invoke "set-externref" (i32.const -1) (ref.extern 0)) "out of bounds table access") +(assert_trap (invoke "set-funcref-from" (i32.const -1) (i32.const 1)) "out of bounds table access") + + +;; Type errors + +(assert_invalid + (module + (table $t 10 externref) + (func $type-index-value-empty-vs-i32-externref + (table.set $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 externref) + (func $type-index-empty-vs-i32 + (table.set $t (ref.null extern)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 externref) + (func $type-value-empty-vs-externref + (table.set $t (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 externref) + (func $type-size-f32-vs-i32 + (table.set $t (f32.const 1) (ref.null extern)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 funcref) + (func $type-value-externref-vs-funcref (param $r externref) + (table.set $t (i32.const 1) (local.get $r)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t1 1 externref) + (table $t2 1 funcref) + (func $type-value-externref-vs-funcref-multi (param $r externref) + (table.set $t2 (i32.const 0) (local.get $r)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 10 externref) + (func $type-result-empty-vs-num (result i32) + (table.set $t (i32.const 0) (ref.null extern)) + ) + ) + "type mismatch" +) diff --git a/tests/requirement-engineering/gc-aot/wasm-apps/type_subtyping.wast b/tests/requirement-engineering/gc-aot/wasm-apps/type_subtyping.wast new file mode 100644 index 00000000..cd73b79e --- /dev/null +++ b/tests/requirement-engineering/gc-aot/wasm-apps/type_subtyping.wast @@ -0,0 +1,804 @@ +;; Definitions + +(module + (type $e0 (sub (array i32))) + (type $e1 (sub $e0 (array i32))) + + (type $e2 (sub (array anyref))) + (type $e3 (sub (array (ref null $e0)))) + (type $e4 (sub (array (ref $e1)))) + + (type $m1 (sub (array (mut i32)))) + (type $m2 (sub $m1 (array (mut i32)))) +) + +(module + (type $e0 (sub (struct))) + (type $e1 (sub $e0 (struct))) + (type $e2 (sub $e1 (struct (field i32)))) + (type $e3 (sub $e2 (struct (field i32 (ref null $e0))))) + (type $e4 (sub $e3 (struct (field i32 (ref $e0) (mut i64))))) + (type $e5 (sub $e4 (struct (field i32 (ref $e1) (mut i64))))) +) + +(module + (type $s (sub (struct))) + (type $s' (sub $s (struct))) + + (type $f1 (sub (func (param (ref $s')) (result anyref)))) + (type $f2 (sub $f1 (func (param (ref $s)) (result (ref any))))) + (type $f3 (sub $f2 (func (param (ref null $s)) (result (ref $s))))) + (type $f4 (sub $f3 (func (param (ref null struct)) (result (ref $s'))))) +) + + +;; Recursive definitions + +(module + (type $t (sub (struct (field anyref)))) + (rec (type $r (sub $t (struct (field (ref $r)))))) + (type $t' (sub $r (struct (field (ref $r) i32)))) +) + +(module + (rec + (type $r1 (sub (struct (field i32 (ref $r1))))) + ) + (rec + (type $r2 (sub $r1 (struct (field i32 (ref $r3))))) + (type $r3 (sub $r1 (struct (field i32 (ref $r2))))) + ) +) + +(module + (rec + (type $a1 (sub (struct (field i32 (ref $a2))))) + (type $a2 (sub (struct (field i64 (ref $a1))))) + ) + (rec + (type $b1 (sub $a2 (struct (field i64 (ref $a1) i32)))) + (type $b2 (sub $a1 (struct (field i32 (ref $a2) i32)))) + (type $b3 (sub $a2 (struct (field i64 (ref $b2) i32)))) + ) +) + + +;; Subsumption + +(module + (rec + (type $t1 (sub (func (param i32 (ref $t3))))) + (type $t2 (sub $t1 (func (param i32 (ref $t2))))) + (type $t3 (sub $t2 (func (param i32 (ref $t1))))) + ) + + (func $f1 (param $r (ref $t1)) + (call $f1 (local.get $r)) + ) + (func $f2 (param $r (ref $t2)) + (call $f1 (local.get $r)) + (call $f2 (local.get $r)) + ) + (func $f3 (param $r (ref $t3)) + (call $f1 (local.get $r)) + (call $f2 (local.get $r)) + (call $f3 (local.get $r)) + ) +) + +(module + (rec + (type $t1 (sub (func (result i32 (ref $u1))))) + (type $u1 (sub (func (result f32 (ref $t1))))) + ) + + (rec + (type $t2 (sub $t1 (func (result i32 (ref $u3))))) + (type $u2 (sub $u1 (func (result f32 (ref $t3))))) + (type $t3 (sub $t1 (func (result i32 (ref $u2))))) + (type $u3 (sub $u1 (func (result f32 (ref $t2))))) + ) + + (func $f1 (param $r (ref $t1)) + (call $f1 (local.get $r)) + ) + (func $f2 (param $r (ref $t2)) + (call $f1 (local.get $r)) + (call $f2 (local.get $r)) + ) + (func $f3 (param $r (ref $t3)) + (call $f1 (local.get $r)) + (call $f3 (local.get $r)) + ) +) + +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f2))))) + (rec (type $g1 (sub $f1 (func))) (type (struct))) + (rec (type $g2 (sub $f2 (func))) (type (struct))) + (func $g (type $g2)) + (global (ref $g1) (ref.func $g)) +) + +(module + (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1)))))) + (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2)))))) + (rec + (type $g1 (sub $f1 (func))) + (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1))))) + ) + (rec + (type $g2 (sub $f2 (func))) + (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2))))) + ) + (func $g (type $g2)) + (global (ref $g1) (ref.func $g)) +) + +(assert_invalid + (module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $g1 (sub $f1 (func))) (type (struct))) + (rec (type $g2 (sub $f2 (func))) (type (struct))) + (func $g (type $g2)) + (global (ref $g1) (ref.func $g)) + ) + "type mismatch" +) + +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f2))))) + (rec (type $g (sub $f1 (func))) (type (struct))) + (func $g (type $g)) + (global (ref $f1) (ref.func $g)) +) + +(module + (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1)))))) + (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2)))))) + (rec + (type $g1 (sub $f1 (func))) + (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1))))) + ) + (rec + (type $g2 (sub $f2 (func))) + (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2))))) + ) + (rec (type $h (sub $g2 (func))) (type (struct))) + (func $h (type $h)) + (global (ref $f1) (ref.func $h)) + (global (ref $g1) (ref.func $h)) +) + + +(module + (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11)))))) + (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21)))))) + (func $f11 (type $f11) (unreachable)) + (func $f12 (type $f12) (unreachable)) + (global (ref $f11) (ref.func $f11)) + (global (ref $f21) (ref.func $f11)) + (global (ref $f12) (ref.func $f12)) + (global (ref $f22) (ref.func $f12)) +) + +(module + (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11)))))) + (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21)))))) + (rec (type $g11 (sub $f11 (func (result (ref func))))) (type $g12 (sub $g11 (func (result (ref $g11)))))) + (rec (type $g21 (sub $f21 (func (result (ref func))))) (type $g22 (sub $g21 (func (result (ref $g21)))))) + (func $g11 (type $g11) (unreachable)) + (func $g12 (type $g12) (unreachable)) + (global (ref $f11) (ref.func $g11)) + (global (ref $f21) (ref.func $g11)) + (global (ref $f11) (ref.func $g12)) + (global (ref $f21) (ref.func $g12)) + (global (ref $g11) (ref.func $g11)) + (global (ref $g21) (ref.func $g11)) + (global (ref $g12) (ref.func $g12)) + (global (ref $g22) (ref.func $g12)) +) + +(assert_invalid + (module + (rec (type $f11 (sub (func))) (type $f12 (sub $f11 (func)))) + (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func)))) + (func $f (type $f21)) + (global (ref $f11) (ref.func $f)) + ) + "type mismatch" +) + +(assert_invalid + (module + (rec (type $f01 (sub (func))) (type $f02 (sub $f01 (func)))) + (rec (type $f11 (sub (func))) (type $f12 (sub $f01 (func)))) + (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func)))) + (func $f (type $f21)) + (global (ref $f11) (ref.func $f)) + ) + "type mismatch" +) + + +;; Runtime types + +(module + (type $t0 (sub (func (result (ref null func))))) + (rec (type $t1 (sub $t0 (func (result (ref null $t1)))))) + (rec (type $t2 (sub $t1 (func (result (ref null $t2)))))) + + (func $f0 (type $t0) (ref.null func)) + (func $f1 (type $t1) (ref.null $t1)) + (func $f2 (type $t2) (ref.null $t2)) + (table funcref (elem $f0 $f1 $f2)) + + (func (export "run") + (block (result (ref null func)) (call_indirect (type $t0) (i32.const 0))) + (block (result (ref null func)) (call_indirect (type $t0) (i32.const 1))) + (block (result (ref null func)) (call_indirect (type $t0) (i32.const 2))) + (block (result (ref null $t1)) (call_indirect (type $t1) (i32.const 1))) + (block (result (ref null $t1)) (call_indirect (type $t1) (i32.const 2))) + (block (result (ref null $t2)) (call_indirect (type $t2) (i32.const 2))) + + (block (result (ref null $t0)) (ref.cast (ref $t0) (table.get (i32.const 0)))) + (block (result (ref null $t0)) (ref.cast (ref $t0) (table.get (i32.const 1)))) + (block (result (ref null $t0)) (ref.cast (ref $t0) (table.get (i32.const 2)))) + (block (result (ref null $t1)) (ref.cast (ref $t1) (table.get (i32.const 1)))) + (block (result (ref null $t1)) (ref.cast (ref $t1) (table.get (i32.const 2)))) + (block (result (ref null $t2)) (ref.cast (ref $t2) (table.get (i32.const 2)))) + (br 0) + ) + + (func (export "fail1") + (block (result (ref null $t1)) (call_indirect (type $t1) (i32.const 0))) + (br 0) + ) + (func (export "fail2") + (block (result (ref null $t1)) (call_indirect (type $t2) (i32.const 0))) + (br 0) + ) + (func (export "fail3") + (block (result (ref null $t1)) (call_indirect (type $t2) (i32.const 1))) + (br 0) + ) + + (func (export "fail4") + (ref.cast (ref $t1) (table.get (i32.const 0))) + (br 0) + ) + (func (export "fail5") + (ref.cast (ref $t2) (table.get (i32.const 0))) + (br 0) + ) + (func (export "fail6") + (ref.cast (ref $t2) (table.get (i32.const 1))) + (br 0) + ) +) +(assert_return (invoke "run")) +(assert_trap (invoke "fail1") "indirect call") +(assert_trap (invoke "fail2") "indirect call") +(assert_trap (invoke "fail3") "indirect call") +(assert_trap (invoke "fail4") "cast") +(assert_trap (invoke "fail5") "cast") +(assert_trap (invoke "fail6") "cast") + +(module + (type $t1 (sub (func))) + (type $t2 (sub final (func))) + + (func $f1 (type $t1)) + (func $f2 (type $t2)) + (table funcref (elem $f1 $f2)) + + (func (export "fail1") + (block (call_indirect (type $t1) (i32.const 1))) + ) + (func (export "fail2") + (block (call_indirect (type $t2) (i32.const 0))) + ) + + (func (export "fail3") + (ref.cast (ref $t1) (table.get (i32.const 1))) + (drop) + ) + (func (export "fail4") + (ref.cast (ref $t2) (table.get (i32.const 0))) + (drop) + ) +) +(assert_trap (invoke "fail1") "indirect call") +(assert_trap (invoke "fail2") "indirect call") +(assert_trap (invoke "fail3") "cast") +(assert_trap (invoke "fail4") "cast") + +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f2))))) + (rec (type $g1 (sub $f1 (func))) (type (struct))) + (rec (type $g2 (sub $f2 (func))) (type (struct))) + (func $g (type $g2)) (elem declare func $g) + (func (export "run") (result i32) + (ref.test (ref $g1) (ref.func $g)) + ) +) +(assert_return (invoke "run") (i32.const 1)) + +(module + (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1)))))) + (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2)))))) + (rec + (type $g1 (sub $f1 (func))) + (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1))))) + ) + (rec + (type $g2 (sub $f2 (func))) + (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2))))) + ) + (func $g (type $g2)) (elem declare func $g) + (func (export "run") (result i32) + (ref.test (ref $g1) (ref.func $g)) + ) +) +(assert_return (invoke "run") (i32.const 1)) + +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $g1 (sub $f1 (func))) (type (struct))) + (rec (type $g2 (sub $f2 (func))) (type (struct))) + (func $g (type $g2)) (elem declare func $g) + (func (export "run") (result i32) + (ref.test (ref $g1) (ref.func $g)) + ) +) +(assert_return (invoke "run") (i32.const 0)) + +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f2))))) + (rec (type $g (sub $f1 (func))) (type (struct))) + (func $g (type $g)) (elem declare func $g) + (func (export "run") (result i32) + (ref.test (ref $f1) (ref.func $g)) + ) +) +(assert_return (invoke "run") (i32.const 1)) + +(module + (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1)))))) + (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2)))))) + (rec + (type $g1 (sub $f1 (func))) + (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1))))) + ) + (rec + (type $g2 (sub $f2 (func))) + (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2))))) + ) + (rec (type $h (sub $g2 (func))) (type (struct))) + (func $h (type $h)) (elem declare func $h) + (func (export "run") (result i32 i32) + (ref.test (ref $f1) (ref.func $h)) + (ref.test (ref $g1) (ref.func $h)) + ) +) +(assert_return (invoke "run") (i32.const 1) (i32.const 1)) + +(module + (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11)))))) + (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21)))))) + (func $f11 (type $f11) (unreachable)) (elem declare func $f11) + (func $f12 (type $f12) (unreachable)) (elem declare func $f12) + (func (export "run") (result i32 i32 i32 i32) + (ref.test (ref $f11) (ref.func $f11)) + (ref.test (ref $f21) (ref.func $f11)) + (ref.test (ref $f12) (ref.func $f12)) + (ref.test (ref $f22) (ref.func $f12)) + ) +) +(assert_return (invoke "run") + (i32.const 1) (i32.const 1) (i32.const 1) (i32.const 1) +) + +(module + (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11)))))) + (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21)))))) + (rec (type $g11 (sub $f11 (func (result (ref func))))) (type $g12 (sub $g11 (func (result (ref $g11)))))) + (rec (type $g21 (sub $f21 (func (result (ref func))))) (type $g22 (sub $g21 (func (result (ref $g21)))))) + (func $g11 (type $g11) (unreachable)) (elem declare func $g11) + (func $g12 (type $g12) (unreachable)) (elem declare func $g12) + (func (export "run") (result i32 i32 i32 i32 i32 i32 i32 i32) + (ref.test (ref $f11) (ref.func $g11)) + (ref.test (ref $f21) (ref.func $g11)) + (ref.test (ref $f11) (ref.func $g12)) + (ref.test (ref $f21) (ref.func $g12)) + (ref.test (ref $g11) (ref.func $g11)) + (ref.test (ref $g21) (ref.func $g11)) + (ref.test (ref $g12) (ref.func $g12)) + (ref.test (ref $g22) (ref.func $g12)) + ) +) +(assert_return (invoke "run") + (i32.const 1) (i32.const 1) (i32.const 1) (i32.const 1) + (i32.const 1) (i32.const 1) (i32.const 1) (i32.const 1) +) + +(module + (rec (type $f11 (sub (func))) (type $f12 (sub $f11 (func)))) + (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func)))) + (func $f (type $f21)) (elem declare func $f) + (func (export "run") (result i32) + (ref.test (ref $f11) (ref.func $f)) + ) +) +(assert_return (invoke "run") (i32.const 0)) + +(module + (rec (type $f01 (sub (func))) (type $f02 (sub $f01 (func)))) + (rec (type $f11 (sub (func))) (type $f12 (sub $f01 (func)))) + (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func)))) + (func $f (type $f21)) (elem declare func $f) + (func (export "run") (result i32) + (ref.test (ref $f11) (ref.func $f)) + ) +) +(assert_return (invoke "run") (i32.const 0)) + + + +;; Linking + +(module + (type $t0 (sub (func (result (ref null func))))) + (rec (type $t1 (sub $t0 (func (result (ref null $t1)))))) + (rec (type $t2 (sub $t1 (func (result (ref null $t2)))))) + + (func (export "f0") (type $t0) (ref.null func)) + (func (export "f1") (type $t1) (ref.null $t1)) + (func (export "f2") (type $t2) (ref.null $t2)) +) +(register "M") + +(module + (type $t0 (sub (func (result (ref null func))))) + (rec (type $t1 (sub $t0 (func (result (ref null $t1)))))) + (rec (type $t2 (sub $t1 (func (result (ref null $t2)))))) + + (func (import "M" "f0") (type $t0)) + (func (import "M" "f1") (type $t0)) + (func (import "M" "f1") (type $t1)) + (func (import "M" "f2") (type $t0)) + (func (import "M" "f2") (type $t1)) + (func (import "M" "f2") (type $t2)) +) + +(assert_unlinkable + (module + (type $t0 (sub (func (result (ref null func))))) + (rec (type $t1 (sub $t0 (func (result (ref null $t1)))))) + (rec (type $t2 (sub $t1 (func (result (ref null $t2)))))) + (func (import "M" "f0") (type $t1)) + ) + "incompatible import type" +) + +(assert_unlinkable + (module + (type $t0 (sub (func (result (ref null func))))) + (rec (type $t1 (sub $t0 (func (result (ref null $t1)))))) + (rec (type $t2 (sub $t1 (func (result (ref null $t2)))))) + (func (import "M" "f0") (type $t2)) + ) + "incompatible import type" +) + +(assert_unlinkable + (module + (type $t0 (sub (func (result (ref null func))))) + (rec (type $t1 (sub $t0 (func (result (ref null $t1)))))) + (rec (type $t2 (sub $t1 (func (result (ref null $t2)))))) + (func (import "M" "f1") (type $t2)) + ) + "incompatible import type" +) + +(module + (type $t1 (sub (func))) + (type $t2 (sub final (func))) + (func (export "f1") (type $t1)) + (func (export "f2") (type $t2)) +) +(register "M2") + +(assert_unlinkable + (module + (type $t1 (sub (func))) + (type $t2 (sub final (func))) + (func (import "M2" "f1") (type $t2)) + ) + "incompatible import type" +) +(assert_unlinkable + (module + (type $t1 (sub (func))) + (type $t2 (sub final (func))) + (func (import "M2" "f2") (type $t1)) + ) + "incompatible import type" +) + + +(module + (rec (type $f2 (sub (func))) (type (struct (field (ref $f2))))) + (rec (type $g2 (sub $f2 (func))) (type (struct))) + (func (export "g") (type $g2)) +) +(register "M3") +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $g1 (sub $f1 (func))) (type (struct))) + (func (import "M3" "g") (type $g1)) +) + +(module + (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1)))))) + (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2)))))) + (rec + (type $g2 (sub $f2 (func))) + (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2))))) + ) + (func (export "g") (type $g2)) +) +(register "M4") +(module + (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1)))))) + (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2)))))) + (rec + (type $g1 (sub $f1 (func))) + (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1))))) + ) + (func (import "M4" "g") (type $g1)) +) + +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $g2 (sub $f2 (func))) (type (struct))) + (func (export "g") (type $g2)) +) +(register "M5") +(assert_unlinkable + (module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $g1 (sub $f1 (func))) (type (struct))) + (func (import "M5" "g") (type $g1)) + ) + "incompatible import" +) + +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f2))))) + (rec (type $g (sub $f1 (func))) (type (struct))) + (func (export "g") (type $g)) +) +(register "M6") +(module + (rec (type $f1 (sub (func))) (type (struct (field (ref $f1))))) + (rec (type $f2 (sub (func))) (type (struct (field (ref $f2))))) + (rec (type $g (sub $f1 (func))) (type (struct))) + (func (import "M6" "g") (type $f1)) +) + +(module + (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1)))))) + (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2)))))) + (rec + (type $g2 (sub $f2 (func))) + (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2))))) + ) + (rec (type $h (sub $g2 (func))) (type (struct))) + (func (export "h") (type $h)) +) +;; (register "M7") +(module + (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1)))))) + (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2)))))) + (rec + (type $g1 (sub $f1 (func))) + (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1))))) + ) + (rec (type $h (sub $g1 (func))) (type (struct))) + (func (import "M7" "h") (type $f1)) + (func (import "M7" "h") (type $g1)) +) + + +(module + (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11)))))) + (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21)))))) + (func (export "f11") (type $f11) (unreachable)) + (func (export "f12") (type $f12) (unreachable)) +) +(register "M8") +(module + (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11)))))) + (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21)))))) + (func (import "M8" "f11") (type $f11)) + (func (import "M8" "f11") (type $f21)) + (func (import "M8" "f12") (type $f12)) + (func (import "M8" "f12") (type $f22)) +) + +(module + (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11)))))) + (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21)))))) + (rec (type $g11 (sub $f11 (func (result (ref func))))) (type $g12 (sub $g11 (func (result (ref $g11)))))) + (rec (type $g21 (sub $f21 (func (result (ref func))))) (type $g22 (sub $g21 (func (result (ref $g21)))))) + (func (export "g11") (type $g11) (unreachable)) + (func (export "g12") (type $g12) (unreachable)) +) +(register "M9") +(module + (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11)))))) + (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21)))))) + (rec (type $g11 (sub $f11 (func (result (ref func))))) (type $g12 (sub $g11 (func (result (ref $g11)))))) + (rec (type $g21 (sub $f21 (func (result (ref func))))) (type $g22 (sub $g21 (func (result (ref $g21)))))) + (func (import "M9" "g11") (type $f11)) + (func (import "M9" "g11") (type $f21)) + (func (import "M9" "g12") (type $f11)) + (func (import "M9" "g12") (type $f21)) + (func (import "M9" "g11") (type $g11)) + (func (import "M9" "g11") (type $g21)) + (func (import "M9" "g12") (type $g12)) + (func (import "M9" "g12") (type $g22)) +) + +(module + (rec (type $f11 (sub (func))) (type $f12 (sub $f11 (func)))) + (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func)))) + (func (export "f") (type $f21)) +) +(register "M10") +(assert_unlinkable + (module + (rec (type $f11 (sub (func))) (type $f12 (sub $f11 (func)))) + (func (import "M10" "f") (type $f11)) + ) + "incompatible import" +) + +(module + (rec (type $f01 (sub (func))) (type $f02 (sub $f01 (func)))) + (rec (type $f11 (sub (func))) (type $f12 (sub $f01 (func)))) + (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func)))) + (func (export "f") (type $f21)) +) +(register "M11") +(assert_unlinkable + (module + (rec (type $f01 (sub (func))) (type $f02 (sub $f01 (func)))) + (rec (type $f11 (sub (func))) (type $f12 (sub $f01 (func)))) + (func (import "M11" "f") (type $f11)) + ) + "incompatible import" +) + + + +;; Finality violation + +(assert_invalid + (module + (type $t (func)) + (type $s (sub $t (func))) + ) + "sub type" +) + +(assert_invalid + (module + (type $t (struct)) + (type $s (sub $t (struct))) + ) + "sub type" +) + +(assert_invalid + (module + (type $t (sub final (func))) + (type $s (sub $t (func))) + ) + "sub type" +) + +(assert_invalid + (module + (type $t (sub (func))) + (type $s (sub final $t (func))) + (type $u (sub $s (func))) + ) + "sub type" +) + + + +;; Invalid subtyping definitions + +(assert_invalid + (module + (type $a0 (sub (array i32))) + (type $s0 (sub $a0 (struct))) + ) + "sub type" +) + +(assert_invalid + (module + (type $f0 (sub (func (param i32) (result i32)))) + (type $s0 (sub $f0 (struct))) + ) + "sub type" +) + +(assert_invalid + (module + (type $s0 (sub (struct))) + (type $a0 (sub $s0 (array i32))) + ) + "sub type" +) + +(assert_invalid + (module + (type $f0 (sub (func (param i32) (result i32)))) + (type $a0 (sub $f0 (array i32))) + ) + "sub type" +) + +(assert_invalid + (module + (type $s0 (sub (struct))) + (type $f0 (sub $s0 (func (param i32) (result i32)))) + ) + "sub type" +) + +(assert_invalid + (module + (type $a0 (sub (array i32))) + (type $f0 (sub $a0 (func (param i32) (result i32)))) + ) + "sub type" +) + +(assert_invalid + (module + (type $a0 (sub (array i32))) + (type $a1 (sub $a0 (array i64))) + ) + "sub type" +) + +(assert_invalid + (module + (type $s0 (sub (struct (field i32)))) + (type $s1 (sub $s0 (struct (field i64)))) + ) + "sub type" +) + +(assert_invalid + (module + (type $f0 (sub (func))) + (type $f1 (sub $f0 (func (param i32)))) + ) + "sub type" +) + diff --git a/tests/wamr-test-suites/requirement-engineering-test-script/run_requirement.py b/tests/wamr-test-suites/requirement-engineering-test-script/run_requirement.py new file mode 100755 index 00000000..2b55db4a --- /dev/null +++ b/tests/wamr-test-suites/requirement-engineering-test-script/run_requirement.py @@ -0,0 +1,215 @@ +#!/usr/bin/python3 +# +# Copyright (C) 2019 Intel Corporation. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +# + +import os +import sys +import argparse +from typing import Dict, Tuple, List +import importlib +import inspect +import csv + +REQUIREMENT_TESTS_DIR = "../../requirement-engineering" +SUBREQUIREMENT_DESCRIPTIONS = {} + + +# To use this empty function to do signature check +def expected_build_func_template(verbose: bool) -> None: + pass + + +# To use this empty function to do signature check +# The actual implementation of the return value should has following information: +# +def expected_run_func_template( + output_dir: str, subrequirement_ids: List[int] +) -> Dict[int, Dict[Tuple[str, str], bool]]: + pass + + +def dynamic_import(requirement_dir: str): + # Declare that we intend to modify the global variable + global SUBREQUIREMENT_DESCRIPTIONS + sys.path.append(requirement_dir) + os.chdir(requirement_dir) + + try: + build_module = importlib.import_module("build") + build_function = getattr(build_module, "build") + except AttributeError: + raise ImportError("'build' function not found in the specified build.py file.") + + try: + run_module = importlib.import_module("run") + run_function = getattr(run_module, "run") + SUBREQUIREMENT_DESCRIPTIONS = getattr(run_module, "SUBREQUIREMENT_DESCRIPTIONS") + except AttributeError: + raise ImportError( + "'run' function or 'SUBREQUIREMENT_DESCRIPTIONS' not found in the specified run.py file." + ) + + # Do signature check + expected_signature = inspect.signature(expected_build_func_template) + actual_signature = inspect.signature(build_function) + assert ( + actual_signature == expected_signature + ), "The build function doesn't have the expected signature" + + expected_signature = inspect.signature(expected_run_func_template) + actual_signature = inspect.signature(run_function) + assert ( + actual_signature == expected_signature + ), "The run function doesn't have the expected signature" + + # Check if the variable is a dictionary + if not isinstance(SUBREQUIREMENT_DESCRIPTIONS, dict): + raise TypeError("SUBREQUIREMENT_DESCRIPTIONS is not a dictionary") + + # Check the types of keys and values in the dictionary + for key, value in SUBREQUIREMENT_DESCRIPTIONS.items(): + if not isinstance(key, int): + raise TypeError("Key in SUBREQUIREMENT_DESCRIPTIONS is not an int") + if not ( + isinstance(value, tuple) + and len(value) == 2 + and all(isinstance(elem, str) for elem in value) + ): + raise TypeError( + "Value in SUBREQUIREMENT_DESCRIPTIONS is not a Tuple[str, str]" + ) + + return build_function, run_function + + +def cmd_line_summary( + requirement_name: str, result_dict: dict, subrequirement_descriptions: dict +): + # command line summary + total, total_pass_nums, total_fail_nums = 0, 0, 0 + print(f"\n============ Start: Summary of {requirement_name} test ============") + for subrequirement_id in result_dict.keys(): + sub_total = len(result_dict[subrequirement_id]) + pass_nums = len( + [_ for _, result in result_dict[subrequirement_id].items() if result] + ) + fail_nums = len( + [_ for _, result in result_dict[subrequirement_id].items() if not result] + ) + issue_number, subrequirement_description = subrequirement_descriptions.get( + subrequirement_id, "" + ) + + print(f"\nTest Sub-requirement id: {subrequirement_id}") + print(f"Issue Number: {issue_number}") + print(f"Sub-requirement description: {subrequirement_description}") + print(f"Number of test cases: {sub_total}") + print(f"Pass: {pass_nums}") + print(f"Fail: {fail_nums}\n") + print( + "----------------------------------------------------------------------------" + ) + total += sub_total + total_pass_nums += pass_nums + total_fail_nums += fail_nums + + print(f"\nTotal Number of test cases: {total}") + print(f"Pass: {total_pass_nums}") + print(f"Fail: {total_fail_nums}\n") + + print(f"============= End: Summary of {requirement_name} test =============\n") + + +def generate_report(output_filename: str, result_dict: dict): + # create a list of column names + column_names = [ + "subrequirement id", + "issue number", + "subrequirement description", + "running mode", + "test case name", + "test case description", + "test case executing result", + ] + + # open the output file in write mode + with open(output_filename + ".csv", "w") as output_file: + # create a csv writer object + csv_writer = csv.writer(output_file) + # write the column names as the first row + csv_writer.writerow(column_names) + # loop through the result_dict + for subrequirement_id, test_cases in result_dict.items(): + # get the subrequirement description from the subrequirement_descriptions dict + issue_number, subrequirement_description = SUBREQUIREMENT_DESCRIPTIONS.get( + subrequirement_id, "" + ) + # loop through the test cases + for test_case, result in test_cases.items(): + # unpack the test case name and description from the tuple + test_case_name, test_case_description = test_case + # convert the result to pass or fail + result = "pass" if result else "fail" + # create a list of values for the current row + row_values = [ + subrequirement_id, + issue_number, + subrequirement_description, + "AOT", + test_case_name, + test_case_description, + result, + ] + # write the row values to the output file + csv_writer.writerow(row_values) + + +def run_requirement( + requirement_name: str, output_dir: str, subrequirement_ids: List[int] +): + requirement_dir = os.path.join(REQUIREMENT_TESTS_DIR, requirement_name) + if not os.path.isdir(requirement_dir): + print(f"No such requirement in directory {requirement_dir} exists") + sys.exit(1) + + output_path = os.path.join(output_dir, requirement_name) + + build_requirement_func, run_requirement_func = dynamic_import(requirement_dir) + + build_requirement_func(verbose=False) + result_dict = run_requirement_func(output_path, subrequirement_ids) + + cmd_line_summary(requirement_name, result_dict, SUBREQUIREMENT_DESCRIPTIONS) + generate_report(output_path, result_dict) + + +def main(): + parser = argparse.ArgumentParser(description="Process command line options.") + + # Define the '-o' option for output directory + parser.add_argument( + "-o", "--output_directory", required=True, help="Report output directory" + ) + + # Define the '-r' option for requirement name + parser.add_argument( + "-r", "--requirement_name", required=True, help="Requirement name" + ) + + # Define the subrequirement IDs as a list of integers + parser.add_argument( + "subrequirement_ids", nargs="*", type=int, help="Subrequirement IDs (optional)" + ) + + # Parse the arguments + args = parser.parse_args() + + run_requirement( + args.requirement_name, args.output_directory, list(args.subrequirement_ids) + ) + + +if __name__ == "__main__": + main() diff --git a/tests/wamr-test-suites/test_wamr.sh b/tests/wamr-test-suites/test_wamr.sh index 0c56acac..b9b298a5 100755 --- a/tests/wamr-test-suites/test_wamr.sh +++ b/tests/wamr-test-suites/test_wamr.sh @@ -28,6 +28,7 @@ function help() echo "-e enable exception handling" echo "-x test SGX" echo "-w enable WASI threads" + echo "-a test all runtimes in sightglass suite" echo "-b use the wabt binary release package instead of compiling from the source code" echo "-g build iwasm with debug version" echo "-v enable GC heap verification" @@ -37,6 +38,10 @@ function help() echo "-C enable code coverage collect" echo "-j set the platform to test" echo "-T set sanitizer to use in tests(ubsan|tsan|asan)" + echo "-r [requirement name] [N [N ...]] specify a requirement name followed by one or more" + echo " subrequirement IDs, if no subrequirement is specificed," + echo " it will run all subrequirements. When this optin is used," + echo " only run requirement tests" } OPT_PARSED="" @@ -73,8 +78,11 @@ QEMU_FIRMWARE="" WASI_TESTSUITE_COMMIT="ee807fc551978490bf1c277059aabfa1e589a6c2" TARGET_LIST=("AARCH64" "AARCH64_VFP" "ARMV7" "ARMV7_VFP" "THUMBV7" "THUMBV7_VFP" \ "RISCV32" "RISCV32_ILP32F" "RISCV32_ILP32D" "RISCV64" "RISCV64_LP64F" "RISCV64_LP64D") +REQUIREMENT_NAME="" +# Initialize an empty array for subrequirement IDs +SUBREQUIREMENT_IDS=() -while getopts ":s:cabgvt:m:MCpSXexwWPGQF:j:T:" opt +while getopts ":s:cabgvt:m:MCpSXexwWPGQF:j:T:r:" opt do OPT_PARSED="TRUE" case $opt in @@ -192,6 +200,19 @@ do echo "sanitizer is " ${OPTARG} WAMR_BUILD_SANITIZER=${OPTARG} ;; + r) + REQUIREMENT_NAME=$OPTARG + # get next arg if there are multiple values after -r + eval "nxarg=\${$((OPTIND))}" + # loop until the next symbol '-' or the end of arguments + while [[ "${nxarg}" =~ ^[0-9]+$ ]]; do + SUBREQUIREMENT_IDS+=("$nxarg") + OPTIND=$((OPTIND+1)) + eval "nxarg=\${$((OPTIND))}" + done + echo "Only Test requirement name: ${REQUIREMENT_NAME}" + [[ ${#SUBREQUIREMENT_IDS[@]} -ne 0 ]] && echo "Choose subrequirement IDs: ${SUBREQUIREMENT_IDS[@]}" + ;; ?) help exit 1 @@ -219,6 +240,7 @@ readonly REPORT_DIR=${WORK_DIR}/report/${DATE} mkdir -p ${REPORT_DIR} readonly WAMR_DIR=${WORK_DIR}/../../.. +readonly REQUIREMENT_SCRIPT_DIR=${WORK_DIR}/../requirement-engineering-test-script if [[ ${SGX_OPT} == "--sgx" ]];then readonly IWASM_LINUX_ROOT_DIR="${WAMR_DIR}/product-mini/platforms/linux-sgx" @@ -442,17 +464,17 @@ function spec_test() popd if [ ! -d "exception-handling" ];then echo "exception-handling not exist, clone it from github" - git clone -b master --single-branch https://github.com/WebAssembly/exception-handling + git clone -b master --single-branch https://github.com/WebAssembly/exception-handling fi pushd exception-handling # restore and clean everything git reset --hard 51c721661b671bb7dc4b3a3acb9e079b49778d36 - + if [[ ${ENABLE_MULTI_MODULE} == 0 ]]; then git apply ../../spec-test-script/exception_handling.patch fi - + popd echo $(pwd) fi @@ -731,6 +753,8 @@ function collect_standalone() ./collect_coverage.sh "${CODE_COV_FILE}" "${STANDALONE_DIR}/test-running-modes/c-embed/build" echo "Collect code coverage of standalone test-ts2" ./collect_coverage.sh "${CODE_COV_FILE}" "${STANDALONE_DIR}/test-ts2/build" + echo "Collect code coverage of standalone test-module-malloc" + ./collect_coverage.sh "${CODE_COV_FILE}" "${STANDALONE_DIR}/test-module-malloc/build" popd > /dev/null 2>&1 fi @@ -858,6 +882,13 @@ function collect_coverage() function trigger() { + # Check if REQUIREMENT_NAME is set, if set, only calling requirement test and early return + if [[ -n $REQUIREMENT_NAME ]]; then + python ${REQUIREMENT_SCRIPT_DIR}/run_requirement.py -o ${REPORT_DIR}/ -r "$REQUIREMENT_NAME" "${SUBREQUIREMENT_IDS[@]}" + # early return with the python script exit status + return $? + fi + local EXTRA_COMPILE_FLAGS="" # default enabled features EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_BULK_MEMORY=1" @@ -907,6 +938,7 @@ function trigger() EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_EXCE_HANDLING=1" EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_TAIL_CALL=1" fi + echo "SANITIZER IS" $WAMR_BUILD_SANITIZER if [[ "$WAMR_BUILD_SANITIZER" == "ubsan" ]]; then